X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fllite%2Ffile.c;h=b4c0028c81d2949d9681f3ffe8ec8f92f8a84fd4;hp=6992c7e49de31fa43973791a794d82c276d272ac;hb=68570176f72515dc10875dcacd7dbdc76dff3eaa;hpb=0a859380c36ac24871f221b35042f76c56b04438 diff --git a/lustre/llite/file.c b/lustre/llite/file.c index 6992c7e..b4c0028 100644 --- a/lustre/llite/file.c +++ b/lustre/llite/file.c @@ -26,10 +26,13 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. */ /* + * Copyright (c) 2011 Whamcloud, Inc. + */ +/* * This file is part of Lustre, http://www.lustre.org/ * Lustre is a trademark of Sun Microsystems, Inc. * @@ -43,7 +46,6 @@ #define DEBUG_SUBSYSTEM S_LLITE #include #include -#include #include #include #include "llite_internal.h" @@ -316,7 +318,8 @@ int ll_file_release(struct inode *inode, struct file *file) /* 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) { @@ -325,13 +328,15 @@ int ll_file_release(struct inode *inode, struct file *file) 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); - if (OBD_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_DUMP_LOG, obd_fail_val)) + if (CFS_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_DUMP_LOG, cfs_fail_val)) libcfs_debug_dumplog(); RETURN(rc); @@ -346,6 +351,7 @@ static int ll_intent_file_open(struct file *file, void *lmm, const int len = file->f_dentry->d_name.len; struct md_op_data *op_data; struct ptlrpc_request *req; + __u32 opc = LUSTRE_OPC_ANY; int rc; ENTRY; @@ -361,12 +367,15 @@ static int ll_intent_file_open(struct file *file, void *lmm, * makes a good candidate for using OPEN lock */ /* If lmmsize & lmm are not 0, we are just setting stripe info * parameters. No need for the open lock */ - if (!lmm && !lmmsize) + if (lmm == NULL && lmmsize == 0) { itp->it_flags |= MDS_OPEN_LOCK; + if (itp->it_flags & FMODE_WRITE) + opc = LUSTRE_OPC_CREATE; + } op_data = ll_prep_md_op_data(NULL, parent->d_inode, file->f_dentry->d_inode, name, len, - O_RDWR, LUSTRE_OPC_ANY, NULL); + O_RDWR, opc, NULL); if (IS_ERR(op_data)) RETURN(PTR_ERR(op_data)); @@ -384,6 +393,9 @@ static int ll_intent_file_open(struct file *file, void *lmm, GOTO(out, rc); } + if (it_disposition(itp, DISP_LOOKUP_NEG)) + GOTO(out, rc = -ENOENT); + if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) { rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp); CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc); @@ -392,9 +404,8 @@ static int ll_intent_file_open(struct file *file, void *lmm, rc = ll_prep_inode(&file->f_dentry->d_inode, req, NULL); if (!rc && itp->d.lustre.it_lock_mode) - md_set_lock_data(sbi->ll_md_exp, - &itp->d.lustre.it_lock_handle, - file->f_dentry->d_inode, NULL); + ll_set_lock_data(sbi->ll_md_exp, file->f_dentry->d_inode, + itp, NULL); out: ptlrpc_req_finished(itp->d.lustre.it_data); @@ -492,9 +503,8 @@ int ll_file_open(struct inode *inode, struct file *file) struct lookup_intent *it, oit = { .it_op = IT_OPEN, .it_flags = file->f_flags }; struct lov_stripe_md *lsm; - struct ptlrpc_request *req = NULL; - struct obd_client_handle **och_p; - __u64 *och_usecount; + struct obd_client_handle **och_p = NULL; + __u64 *och_usecount = NULL; struct ll_file_data *fd; int rc = 0, opendir_set = 0; ENTRY; @@ -502,22 +512,18 @@ int ll_file_open(struct inode *inode, struct file *file) CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), flags %o\n", inode->i_ino, inode->i_generation, inode, file->f_flags); -#ifdef HAVE_VFS_INTENT_PATCHES - it = file->f_it; -#else it = file->private_data; /* XXX: compat macro */ file->private_data = NULL; /* prevent ll_local_open assertion */ -#endif fd = ll_file_data_get(); if (fd == NULL) - RETURN(-ENOMEM); + GOTO(out_och_free, rc = -ENOMEM); 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; @@ -543,7 +549,7 @@ int ll_file_open(struct inode *inode, struct file *file) * 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) + 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 @@ -580,9 +586,9 @@ restart: rc = it_open_error(DISP_OPEN_OPEN, it); if (rc) { cfs_up(&lli->lli_och_sem); - ll_file_data_put(fd); GOTO(out_openerr, rc); } + ll_release_openhandle(file->f_dentry, it); lprocfs_counter_incr(ll_i2sbi(inode)->ll_stats, LPROC_LL_OPEN); @@ -593,7 +599,6 @@ restart: if (rc) { (*och_usecount)--; cfs_up(&lli->lli_och_sem); - ll_file_data_put(fd); GOTO(out_openerr, rc); } } else { @@ -608,25 +613,16 @@ restart: it->it_create_mode |= M_CHECK_STALE; rc = ll_intent_file_open(file, NULL, 0, it); it->it_create_mode &= ~M_CHECK_STALE; - if (rc) { - ll_file_data_put(fd); + if (rc) GOTO(out_openerr, rc); - } - /* Got some error? Release the request */ - if (it->d.lustre.it_status < 0) { - req = it->d.lustre.it_data; - ptlrpc_req_finished(req); - } goto restart; } OBD_ALLOC(*och_p, sizeof (struct obd_client_handle)); - if (!*och_p) { - ll_file_data_put(fd); + if (!*och_p) GOTO(out_och_free, rc = -ENOMEM); - } + (*och_usecount)++; - req = it->d.lustre.it_data; /* md_intent_lock() didn't get a request ref if there was an * open error, so don't do cleanup on the request here @@ -634,25 +630,24 @@ restart: /* XXX (green): Should not we bail out on any error here, not * just open error? */ rc = it_open_error(DISP_OPEN_OPEN, it); - if (rc) { - ll_file_data_put(fd); + if (rc) GOTO(out_och_free, rc); - } + + 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) { - ll_file_data_put(fd); + if (rc) GOTO(out_och_free, rc); - } } cfs_up(&lli->lli_och_sem); + fd = NULL; /* Must do this outside lli_och_sem 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)) - GOTO(out, rc); + GOTO(out_och_free, rc); ll_capa_open(inode); @@ -661,26 +656,31 @@ restart: if (file->f_flags & O_LOV_DELAY_CREATE || !(file->f_mode & FMODE_WRITE)) { CDEBUG(D_INODE, "object creation was delayed\n"); - GOTO(out, rc); + GOTO(out_och_free, rc); } } file->f_flags &= ~O_LOV_DELAY_CREATE; - GOTO(out, rc); -out: - ptlrpc_req_finished(req); - if (req) - it_clear_disposition(it, DISP_ENQ_OPEN_REF); + GOTO(out_och_free, rc); + out_och_free: + if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) { + ptlrpc_req_finished(it->d.lustre.it_data); + it_clear_disposition(it, DISP_ENQ_OPEN_REF); + } + if (rc) { - if (*och_p) { + if (och_p && *och_p) { OBD_FREE(*och_p, sizeof (struct obd_client_handle)); *och_p = NULL; /* OBD_FREE writes some magic there */ (*och_usecount)--; } cfs_up(&lli->lli_och_sem); + out_openerr: if (opendir_set != 0) ll_stop_statahead(inode, lli->lli_opendir_key); + if (fd != NULL) + ll_file_data_put(fd); } return rc; @@ -751,7 +751,7 @@ int ll_inode_getattr(struct inode *inode, struct obdo *obdo, 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)); @@ -778,6 +778,9 @@ int ll_merge_lvb(struct inode *inode) lvb.lvb_ctime = lli->lli_lvb.lvb_ctime; rc = obd_merge_lvb(sbi->ll_dt_exp, lli->lli_smd, &lvb, 0); cl_isize_write_nolock(inode, lvb.lvb_size); + + CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n", + PFID(&lli->lli_fid), lvb.lvb_size); inode->i_blocks = lvb.lvb_blocks; LTIME_S(inode->i_mtime) = lvb.lvb_mtime; @@ -809,7 +812,6 @@ void ll_io_init(struct cl_io *io, const struct file *file, int write) { struct inode *inode = file->f_dentry->d_inode; - memset(io, 0, sizeof *io); io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK; if (write) io->u.ci_wr.wr_append = !!(file->f_flags & O_APPEND); @@ -827,17 +829,17 @@ static ssize_t ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args, struct file *file, enum cl_io_type iot, loff_t *ppos, size_t count) { - struct cl_io *io; - ssize_t result; + struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode); + struct cl_io *io; + ssize_t result; ENTRY; - io = &ccc_env_info(env)->cti_io; + io = ccc_env_thread_io(env); ll_io_init(io, file, iot == CIT_WRITE); 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); - struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode); int write_sem_locked = 0; cio->cui_fd = LUSTRE_FPRIVATE(file); @@ -853,8 +855,11 @@ static ssize_t ll_file_io_generic(const struct lu_env *env, #endif if ((iot == CIT_WRITE) && !(cio->cui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) { - cfs_down(&lli->lli_write_sem); + if(cfs_down_interruptible(&lli->lli_write_sem)) + GOTO(out, result = -ERESTARTSYS); write_sem_locked = 1; + } else if (iot == CIT_READ) { + cfs_down_read(&lli->lli_trunc_sem); } break; case IO_SENDFILE: @@ -872,6 +877,8 @@ static ssize_t ll_file_io_generic(const struct lu_env *env, result = cl_io_loop(env, io); if (write_sem_locked) cfs_up(&lli->lli_write_sem); + else if (args->via_io_subtype == IO_NORMAL && iot == CIT_READ) + cfs_up_read(&lli->lli_trunc_sem); } else { /* cl_io_rw_init() handled IO */ result = io->ci_result; @@ -881,8 +888,25 @@ static ssize_t ll_file_io_generic(const struct lu_env *env, result = io->ci_nob; *ppos = io->u.ci_wr.wr.crw_pos; } + GOTO(out, result); +out: cl_io_fini(env, io); - RETURN(result); + + if (iot == CIT_READ) { + if (result >= 0) + ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode), + LPROC_LL_READ_BYTES, result); + } else if (iot == CIT_WRITE) { + if (result >= 0) { + ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode), + LPROC_LL_WRITE_BYTES, result); + lli->lli_write_rc = 0; + } else { + lli->lli_write_rc = result; + } + } + + return result; } @@ -1195,11 +1219,10 @@ static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos, } #endif -static int ll_lov_recreate_obj(struct inode *inode, struct file *file, - unsigned long arg) +static int ll_lov_recreate(struct inode *inode, obd_id id, obd_seq seq, + obd_count ost_idx) { struct obd_export *exp = ll_i2dtexp(inode); - struct ll_recreate_obj ucreatp; struct obd_trans_info oti = { 0 }; struct obdo *oa = NULL; int lsm_size; @@ -1207,13 +1230,6 @@ static int ll_lov_recreate_obj(struct inode *inode, struct file *file, struct lov_stripe_md *lsm, *lsm2; ENTRY; - if (!cfs_capable(CFS_CAP_SYS_ADMIN)) - RETURN(-EPERM); - - if (cfs_copy_from_user(&ucreatp, (struct ll_recreate_obj *)arg, - sizeof(struct ll_recreate_obj))) - RETURN(-EFAULT); - OBDO_ALLOC(oa); if (oa == NULL) RETURN(-ENOMEM); @@ -1225,13 +1241,13 @@ static int ll_lov_recreate_obj(struct inode *inode, struct file *file, lsm_size = sizeof(*lsm) + (sizeof(struct lov_oinfo) * (lsm->lsm_stripe_count)); - OBD_ALLOC(lsm2, lsm_size); + OBD_ALLOC_LARGE(lsm2, lsm_size); if (lsm2 == NULL) GOTO(out, rc = -ENOMEM); - oa->o_id = ucreatp.lrc_id; - oa->o_seq = ucreatp.lrc_seq; - oa->o_nlink = ucreatp.lrc_ost_idx; + oa->o_id = id; + oa->o_seq = seq; + 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 | @@ -1239,7 +1255,7 @@ static int ll_lov_recreate_obj(struct inode *inode, struct file *file, memcpy(lsm2, lsm, lsm_size); rc = obd_create(exp, oa, &lsm2, &oti); - OBD_FREE(lsm2, lsm_size); + OBD_FREE_LARGE(lsm2, lsm_size); GOTO(out, rc); out: ll_inode_size_unlock(inode, 0); @@ -1247,6 +1263,41 @@ out: return rc; } +static int ll_lov_recreate_obj(struct inode *inode, unsigned long arg) +{ + struct ll_recreate_obj ucreat; + ENTRY; + + if (!cfs_capable(CFS_CAP_SYS_ADMIN)) + RETURN(-EPERM); + + if (cfs_copy_from_user(&ucreat, (struct ll_recreate_obj *)arg, + sizeof(struct ll_recreate_obj))) + RETURN(-EFAULT); + + RETURN(ll_lov_recreate(inode, ucreat.lrc_id, 0, + ucreat.lrc_ost_idx)); +} + +static int ll_lov_recreate_fid(struct inode *inode, unsigned long arg) +{ + struct lu_fid fid; + obd_id id; + obd_count ost_idx; + ENTRY; + + if (!cfs_capable(CFS_CAP_SYS_ADMIN)) + RETURN(-EPERM); + + if (cfs_copy_from_user(&fid, (struct lu_fid *)arg, + sizeof(struct lu_fid))) + RETURN(-EFAULT); + + id = fid_oid(&fid) | ((fid_seq(&fid) & 0xffff) << 32); + ost_idx = (fid_seq(&fid) >> 16) & 0xffff; + RETURN(ll_lov_recreate(inode, id, 0, ost_idx)); +} + int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file, int flags, struct lov_user_md *lum, int lum_size) { @@ -1267,8 +1318,6 @@ int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file, rc = ll_intent_file_open(file, lum, lum_size, &oit); if (rc) GOTO(out, rc); - if (it_disposition(&oit, DISP_LOOKUP_NEG)) - GOTO(out_req_free, rc = -ENOENT); rc = oit.d.lustre.it_status; if (rc < 0) GOTO(out_req_free, rc); @@ -1302,8 +1351,8 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, 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); @@ -1375,18 +1424,18 @@ static int ll_lov_setea(struct inode *inode, struct file *file, if (!cfs_capable(CFS_CAP_SYS_ADMIN)) RETURN(-EPERM); - OBD_ALLOC(lump, lum_size); + OBD_ALLOC_LARGE(lump, lum_size); if (lump == NULL) { RETURN(-ENOMEM); } if (cfs_copy_from_user(lump, (struct lov_user_md *)arg, lum_size)) { - OBD_FREE(lump, lum_size); + OBD_FREE_LARGE(lump, lum_size); RETURN(-EFAULT); } rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size); - OBD_FREE(lump, lum_size); + OBD_FREE_LARGE(lump, lum_size); RETURN(rc); } @@ -1426,12 +1475,13 @@ static int ll_lov_setstripe(struct inode *inode, struct file *file, static int ll_lov_getstripe(struct inode *inode, unsigned long arg) { struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd; + int rc = -ENODATA; + ENTRY; - if (!lsm) - RETURN(-ENODATA); - - return obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0, lsm, - (void *)arg); + if (lsm != NULL) + rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0, + lsm, (void *)arg); + RETURN(rc); } int ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg) @@ -1547,9 +1597,10 @@ int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it) inode, och); out: /* this one is in place of ll_file_open */ - if (it_disposition(it, DISP_ENQ_OPEN_REF)) + if (it_disposition(it, DISP_ENQ_OPEN_REF)) { ptlrpc_req_finished(it->d.lustre.it_data); - it_clear_disposition(it, DISP_ENQ_OPEN_REF); + it_clear_disposition(it, DISP_ENQ_OPEN_REF); + } RETURN(rc); } @@ -1659,7 +1710,7 @@ static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg) num_bytes = sizeof(*fiemap_s) + (extent_count * sizeof(struct ll_fiemap_extent)); - OBD_VMALLOC(fiemap_s, num_bytes); + OBD_ALLOC_LARGE(fiemap_s, num_bytes); if (fiemap_s == NULL) RETURN(-ENOMEM); @@ -1692,15 +1743,22 @@ static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg) rc = -EFAULT; error: - OBD_VFREE(fiemap_s, num_bytes); + OBD_FREE_LARGE(fiemap_s, num_bytes); RETURN(rc); } +#ifdef HAVE_UNLOCKED_IOCTL +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, @@ -1744,7 +1802,9 @@ int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd, case LL_IOC_LOV_GETSTRIPE: RETURN(ll_lov_getstripe(inode, arg)); case LL_IOC_RECREATE_OBJ: - RETURN(ll_lov_recreate_obj(inode, file, arg)); + RETURN(ll_lov_recreate_obj(inode, arg)); + case LL_IOC_RECREATE_FID: + RETURN(ll_lov_recreate_fid(inode, arg)); case FSFILT_IOC_FIEMAP: RETURN(ll_ioctl_fiemap(inode, arg)); case FSFILT_IOC_GETFLAGS: @@ -1777,7 +1837,6 @@ int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd, } case OBD_IOC_FID2PATH: RETURN(ll_fid2path(ll_i2mdexp(inode), (void *)arg)); - case LL_IOC_GET_MDTIDX: { int mdtidx; @@ -1790,6 +1849,16 @@ int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd, RETURN(0); } + case OBD_IOC_GETNAME: { + struct obd_device *obd = + class_exp2obd(ll_i2sbi(inode)->ll_dt_exp); + if (!obd) + RETURN(-EFAULT); + if (cfs_copy_to_user((void *)arg, obd->obd_name, + strlen(obd->obd_name) + 1)) + RETURN(-EFAULT); + RETURN(0); + } default: { int err; @@ -1811,18 +1880,15 @@ loff_t ll_file_seek(struct file *file, loff_t offset, int origin) 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); @@ -1842,9 +1908,43 @@ loff_t ll_file_seek(struct file *file, loff_t offset, int origin) RETURN(retval); } +#ifdef HAVE_FLUSH_OWNER_ID +int ll_flush(struct file *file, fl_owner_t id) +#else +int ll_flush(struct file *file) +#endif +{ + struct inode *inode = file->f_dentry->d_inode; + struct ll_inode_info *lli = ll_i2info(inode); + 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; + + /* catch async errors that were recorded back when async writeback + * failed for pages in this mapping. */ + rc = lli->lli_async_rc; + lli->lli_async_rc = 0; + if (lsm) { + err = lov_test_and_clear_async_rc(lsm); + if (rc == 0) + rc = err; + } + + return rc ? -EIO : 0; +} + +#ifndef HAVE_FILE_FSYNC_2ARGS int ll_fsync(struct file *file, struct dentry *dentry, int data) +#else +int ll_fsync(struct file *file, 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; @@ -1861,14 +1961,16 @@ int ll_fsync(struct file *file, struct dentry *dentry, int data) /* 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); @@ -1881,27 +1983,33 @@ int ll_fsync(struct file *file, struct dentry *dentry, int data) ptlrpc_req_finished(req); if (data && lsm) { - struct obdo *oa; + struct obd_info *oinfo; - OBDO_ALLOC(oa); - if (!oa) + OBD_ALLOC_PTR(oinfo); + if (!oinfo) RETURN(rc ? rc : -ENOMEM); - - oa->o_id = lsm->lsm_object_id; - oa->o_seq = lsm->lsm_object_seq; - oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP; - obdo_from_inode(oa, inode, &ll_i2info(inode)->lli_fid, + 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); - - oc = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE); - err = obd_sync(ll_i2sbi(inode)->ll_dt_exp, oa, lsm, - 0, OBD_OBJECT_EOF, oc); - capa_put(oc); + 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); if (!rc) rc = err; - OBDO_FREE(oa); + OBDO_FREE(oinfo->oi_oa); + OBD_FREE_PTR(oinfo); + lli->lli_write_rc = rc < 0 ? rc : 0; } RETURN(rc); @@ -1916,7 +2024,7 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) .ei_cbdata = file_lock }; struct md_op_data *op_data; struct lustre_handle lockh = {0}; - ldlm_policy_data_t flock; + ldlm_policy_data_t flock = {{0}}; int flags = 0; int rc; ENTRY; @@ -1928,13 +2036,28 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) if (file_lock->fl_flags & FL_FLOCK) { LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK)); - /* set missing params for flock() calls */ - file_lock->fl_end = OFFSET_MAX; - file_lock->fl_pid = current->tgid; + /* flocks are whole-file locks */ + flock.l_flock.end = OFFSET_MAX; + /* For flocks owner is determined by the local file desctiptor*/ + flock.l_flock.owner = (unsigned long)file_lock->fl_file; + } else if (file_lock->fl_flags & FL_POSIX) { + flock.l_flock.owner = (unsigned long)file_lock->fl_owner; + flock.l_flock.start = file_lock->fl_start; + flock.l_flock.end = file_lock->fl_end; + } else { + RETURN(-EINVAL); } flock.l_flock.pid = file_lock->fl_pid; - flock.l_flock.start = file_lock->fl_start; - flock.l_flock.end = file_lock->fl_end; + + /* Somewhat ugly workaround for svc lockd. + * lockd installs custom fl_lmops->fl_compare_owner that checks + * for the fl_owner to be the same (which it always is on local node + * I guess between lockd processes) and then compares pid. + * As such we assign pid to the owner field to make it all work, + * conflict with normal locks is unlikely since pid space and + * pointer space for current->files are not intersecting */ + if (file_lock->fl_lmops && file_lock->fl_lmops->fl_compare_owner) + flock.l_flock.owner = (unsigned long)file_lock->fl_pid; switch (file_lock->fl_type) { case F_RDLCK: @@ -1955,8 +2078,9 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) 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) { @@ -2020,26 +2144,55 @@ int ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock) RETURN(-ENOSYS); } -int ll_have_md_lock(struct inode *inode, __u64 bits) +/** + * test if some locks matching bits and l_req_mode are acquired + * - bits can be in different locks + * - if found clear the common lock bits in *bits + * - the bits not found, are kept in *bits + * \param inode [IN] + * \param bits [IN] searched lock bits [IN] + * \param l_req_mode [IN] searched lock mode + * \retval boolean, true iff all bits are found + */ +int ll_have_md_lock(struct inode *inode, __u64 *bits, ldlm_mode_t l_req_mode) { struct lustre_handle lockh; - ldlm_policy_data_t policy = { .l_inodebits = {bits}}; + ldlm_policy_data_t policy; + ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ? + (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode; struct lu_fid *fid; int flags; + int i; ENTRY; if (!inode) RETURN(0); fid = &ll_i2info(inode)->lli_fid; - CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid)); + CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid), + ldlm_lockname[mode]); flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK; - if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy, - LCK_CR|LCK_CW|LCK_PR|LCK_PW, &lockh)) { - RETURN(1); + for (i = 0; i < MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) { + policy.l_inodebits.bits = *bits & (1 << i); + if (policy.l_inodebits.bits == 0) + continue; + + if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, + &policy, mode, &lockh)) { + struct ldlm_lock *lock; + + lock = ldlm_handle2lock(&lockh); + if (lock) { + *bits &= + ~(lock->l_policy_data.l_inodebits.bits); + LDLM_LOCK_PUT(lock); + } else { + *bits &= ~policy.l_inodebits.bits; + } + } } - RETURN(0); + RETURN(*bits == 0); } ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits, @@ -2086,7 +2239,6 @@ int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, { struct inode *inode = dentry->d_inode; struct ptlrpc_request *req = NULL; - struct ll_sb_info *sbi; struct obd_export *exp; int rc = 0; ENTRY; @@ -2095,17 +2247,22 @@ int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, 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); exp = ll_i2mdexp(inode); + /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC. + * But under CMD case, it caused some lock issues, should be fixed + * with new CMD ibits lock. See bug 12718 */ if (exp->exp_connect_flags & OBD_CONNECT_ATTRFID) { struct lookup_intent oit = { .it_op = IT_GETATTR }; struct md_op_data *op_data; + if (ibits == MDS_INODELOCK_LOOKUP) + oit.it_op = IT_LOOKUP; + /* Call getattr by fid, so do not provide name at all. */ op_data = ll_prep_md_op_data(NULL, dentry->d_parent->d_inode, dentry->d_inode, NULL, 0, 0, @@ -2145,7 +2302,7 @@ int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, } ll_lookup_finish_locks(&oit, dentry); - } else if (!ll_have_md_lock(dentry->d_inode, ibits)) { + } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) { struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode); obd_valid valid = OBD_MD_FLGETATTR; struct md_op_data *op_data; @@ -2161,8 +2318,8 @@ int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, 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 @@ -2182,14 +2339,14 @@ out: return rc; } -int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it) +int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, + __u64 ibits) { struct inode *inode = dentry->d_inode; int rc; ENTRY; - rc = __ll_inode_revalidate_it(dentry, it, MDS_INODELOCK_UPDATE | - MDS_INODELOCK_LOOKUP); + rc = __ll_inode_revalidate_it(dentry, it, ibits); /* if object not yet allocated, don't validate size */ if (rc == 0 && ll_i2info(dentry->d_inode)->lli_smd == NULL) { @@ -2199,11 +2356,11 @@ int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it) 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); } @@ -2212,16 +2369,22 @@ int ll_getattr_it(struct vfsmount *mnt, struct dentry *de, struct lookup_intent *it, struct kstat *stat) { struct inode *inode = de->d_inode; + struct ll_sb_info *sbi = ll_i2sbi(inode); + struct ll_inode_info *lli = ll_i2info(inode); int res = 0; - res = ll_inode_revalidate_it(de, it); - ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_GETATTR, 1); + res = ll_inode_revalidate_it(de, it, MDS_INODELOCK_UPDATE | + MDS_INODELOCK_LOOKUP); + ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1); if (res) return res; stat->dev = inode->i_sb->s_dev; - stat->ino = inode->i_ino; + if (ll_need_32bit_api(sbi)) + stat->ino = cl_fid_build_ino(&lli->lli_fid, 1); + else + stat->ino = inode->i_ino; stat->mode = inode->i_mode; stat->nlink = inode->i_nlink; stat->uid = inode->i_uid; @@ -2259,7 +2422,7 @@ int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, num_bytes = sizeof(*fiemap) + (extent_count * sizeof(struct ll_fiemap_extent)); - OBD_VMALLOC(fiemap, num_bytes); + OBD_ALLOC_LARGE(fiemap, num_bytes); if (fiemap == NULL) RETURN(-ENOMEM); @@ -2278,14 +2441,18 @@ int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, memcpy(fieinfo->fi_extents_start, &fiemap->fm_extents[0], fiemap->fm_mapped_extents * sizeof(struct ll_fiemap_extent)); - OBD_VFREE(fiemap, num_bytes); + OBD_FREE_LARGE(fiemap, num_bytes); 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); @@ -2293,6 +2460,10 @@ int lustre_check_acl(struct inode *inode, int mask) 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); @@ -2309,11 +2480,14 @@ int lustre_check_acl(struct inode *inode, int mask) #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; @@ -2338,61 +2512,10 @@ int ll_inode_permission(struct inode *inode, int mask) 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 (current->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 @@ -2412,7 +2535,11 @@ struct file_operations ll_file_operations = { .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, @@ -2424,6 +2551,7 @@ struct file_operations ll_file_operations = { .splice_read = ll_file_splice_read, #endif .fsync = ll_fsync, + .flush = ll_flush }; struct file_operations ll_file_operations_flock = { @@ -2431,7 +2559,11 @@ struct file_operations ll_file_operations_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, @@ -2443,6 +2575,7 @@ struct file_operations ll_file_operations_flock = { .splice_read = ll_file_splice_read, #endif .fsync = ll_fsync, + .flush = ll_flush, #ifdef HAVE_F_OP_FLOCK .flock = ll_file_flock, #endif @@ -2455,7 +2588,11 @@ struct file_operations ll_file_operations_noflock = { .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, @@ -2467,6 +2604,7 @@ struct file_operations ll_file_operations_noflock = { .splice_read = ll_file_splice_read, #endif .fsync = ll_fsync, + .flush = ll_flush, #ifdef HAVE_F_OP_FLOCK .flock = ll_file_noflock, #endif @@ -2474,9 +2612,6 @@ struct file_operations ll_file_operations_noflock = { }; struct inode_operations ll_file_inode_operations = { -#ifdef HAVE_VFS_INTENT_PATCHES - .setattr_raw = ll_setattr_raw, -#endif .setattr = ll_setattr, .truncate = ll_truncate, .getattr = ll_getattr,