X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fllite%2Ffile.c;h=cb325704f1f990fb74ed6eb475f9d8df88312699;hp=e7798c3eda380a9ea6b91bd7ed82224c54b69cf1;hb=4502a37ce21a25da5b1f0cf717ee94352b9def1b;hpb=1c359423c13c02974fee7cdd35f6599f022f8f4b diff --git a/lustre/llite/file.c b/lustre/llite/file.c index e7798c3..cb32570 100644 --- a/lustre/llite/file.c +++ b/lustre/llite/file.c @@ -1,25 +1,43 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Copyright (c) 2002, 2003 Cluster File Systems, Inc. - * Author: Peter Braam - * Author: Phil Schwan - * Author: Andreas Dilger + * GPL HEADER START * - * This file is part of Lustre, http://www.lustre.org. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * Lustre is free software; you can redistribute it and/or - * modify it under the terms of version 2 of the GNU General Public - * License as published by the Free Software Foundation. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. * - * Lustre is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * You should have received a copy of the GNU General Public License - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * You should have received a copy of the GNU General Public License + * version 2 along with this program; If not, see + * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + * GPL HEADER END + */ +/* + * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Use is subject to license terms. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. + * + * lustre/llite/file.c + * + * Author: Peter Braam + * Author: Phil Schwan + * Author: Andreas Dilger */ #define DEBUG_SUBSYSTEM S_LLITE @@ -28,17 +46,16 @@ #include #include #include -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) -#include -#endif #include "llite_internal.h" +#include + +#include "cl_object.h" -/* also used by llite/special.c:ll_special_open() */ struct ll_file_data *ll_file_data_get(void) { struct ll_file_data *fd; - OBD_SLAB_ALLOC_PTR(fd, ll_file_data_slab); + OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, CFS_ALLOC_IO); return fd; } @@ -56,14 +73,19 @@ void ll_pack_inode2opdata(struct inode *inode, struct md_op_data *op_data, op_data->op_attr.ia_atime = inode->i_atime; op_data->op_attr.ia_mtime = inode->i_mtime; op_data->op_attr.ia_ctime = inode->i_ctime; - op_data->op_attr.ia_size = inode->i_size; + op_data->op_attr.ia_size = i_size_read(inode); op_data->op_attr_blocks = inode->i_blocks; ((struct ll_iattr *)&op_data->op_attr)->ia_attr_flags = inode->i_flags; op_data->op_ioepoch = ll_i2info(inode)->lli_ioepoch; - memcpy(&op_data->op_handle, fh, sizeof(op_data->op_handle)); + if (fh) + op_data->op_handle = *fh; op_data->op_capa1 = ll_mdscapa_get(inode); } +/** + * Closes the IO epoch and packs all the attributes into @op_data for + * the CLOSE rpc. + */ static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data, struct obd_client_handle *och) { @@ -75,14 +97,15 @@ static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data, if (!(och->och_flags & FMODE_WRITE)) goto out; - if (!(ll_i2mdexp(inode)->exp_connect_flags & OBD_CONNECT_SOM) || - !S_ISREG(inode->i_mode)) + if (!exp_connect_som(ll_i2mdexp(inode)) || !S_ISREG(inode->i_mode)) op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS; else - ll_epoch_close(inode, op_data, &och, 0); + ll_ioepoch_close(inode, op_data, &och, 0); out: ll_pack_inode2opdata(inode, op_data, &och->och_fh); + ll_prep_md_op_data(op_data, inode, NULL, NULL, + 0, 0, LUSTRE_OPC_ANY, NULL); EXIT; } @@ -108,30 +131,19 @@ static int ll_close_inode_openhandle(struct obd_export *md_exp, GOTO(out, rc = 0); } - /* - * here we check if this is forced umount. If so this is called on - * canceling "open lock" and we do not call md_close() in this case, as - * it will not be successful, as import is already deactivated. - */ - if (obd->obd_force) - GOTO(out, rc = 0); - OBD_ALLOC_PTR(op_data); if (op_data == NULL) GOTO(out, rc = -ENOMEM); // XXX We leak openhandle and request here. ll_prepare_close(inode, op_data, och); epoch_close = (op_data->op_flags & MF_EPOCH_CLOSE); - rc = md_close(md_exp, op_data, och, &req); - + rc = md_close(md_exp, op_data, och->och_mod, &req); if (rc == -EAGAIN) { /* This close must have the epoch closed. */ - LASSERT(exp->exp_connect_flags & OBD_CONNECT_SOM); LASSERT(epoch_close); /* MDS has instructed us to obtain Size-on-MDS attribute from * OSTs and send setattr to back to MDS. */ - rc = ll_sizeonmds_update(inode, &och->och_fh, - op_data->op_ioepoch); + rc = ll_som_update(inode, op_data); if (rc) { CERROR("inode %lu mdc Size-on-MDS update failed: " "rc = %d\n", inode->i_ino, rc); @@ -150,11 +162,10 @@ static int ll_close_inode_openhandle(struct obd_export *md_exp, inode->i_ino, rc); } - ptlrpc_req_finished(req); /* This is close request */ EXIT; out: - - if ((exp->exp_connect_flags & OBD_CONNECT_SOM) && !epoch_close && + + if (exp_connect_som(exp) && !epoch_close && S_ISREG(inode->i_mode) && (och->och_flags & FMODE_WRITE)) { ll_queue_done_writing(inode, LLIF_DONE_WRITING); } else { @@ -163,7 +174,8 @@ out: och->och_fh.cookie = DEAD_HANDLE_MAGIC; OBD_FREE_PTR(och); } - + if (req) /* This is close request */ + ptlrpc_req_finished(req); return rc; } @@ -216,12 +228,8 @@ int ll_md_close(struct obd_export *md_exp, struct inode *inode, ENTRY; /* clear group lock, if present */ - if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED)) { - struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd; - fd->fd_flags &= ~(LL_FILE_GROUP_LOCKED|LL_FILE_IGNORE_LOCK); - rc = ll_extent_unlock(fd, inode, lsm, LCK_GROUP, - &fd->fd_cwlockh); - } + if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED)) + ll_put_grouplock(inode, file, fd->fd_grouplock.cg_gid); /* Let's see if we have good enough OPEN lock on the file and if we can skip talking to MDS */ @@ -280,31 +288,51 @@ int ll_file_release(struct inode *inode, struct file *file) struct ll_inode_info *lli = ll_i2info(inode); struct lov_stripe_md *lsm = lli->lli_smd; int rc; - ENTRY; + CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino, inode->i_generation, inode); - /* don't do anything for / */ - if (inode->i_sb->s_root == file->f_dentry) - RETURN(0); +#ifdef CONFIG_FS_POSIX_ACL + if (sbi->ll_flags & LL_SBI_RMT_CLIENT && + inode == inode->i_sb->s_root->d_inode) { + struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + + LASSERT(fd != NULL); + if (unlikely(fd->fd_flags & LL_FILE_RMTACL)) { + fd->fd_flags &= ~LL_FILE_RMTACL; + rct_del(&sbi->ll_rct, cfs_curproc_pid()); + et_search_free(&sbi->ll_et, cfs_curproc_pid()); + } + } +#endif - ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1); + if (inode->i_sb->s_root != file->f_dentry) + ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1); fd = LUSTRE_FPRIVATE(file); LASSERT(fd != NULL); - /* don't do anything for / */ + /* 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) + ll_stop_statahead(inode, lli->lli_opendir_key); + if (inode->i_sb->s_root == file->f_dentry) { LUSTRE_FPRIVATE(file) = NULL; ll_file_data_put(fd); RETURN(0); } - + 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)) + libcfs_debug_dumplog(); + RETURN(rc); } @@ -318,6 +346,7 @@ static int ll_intent_file_open(struct file *file, void *lmm, struct md_op_data *op_data; struct ptlrpc_request *req; int rc; + ENTRY; if (!parent) RETURN(-ENOENT); @@ -347,36 +376,47 @@ static int ll_intent_file_open(struct file *file, void *lmm, /* reason for keep own exit path - don`t flood log * with messages with -ESTALE errors. */ - if (!it_disposition(itp, DISP_OPEN_OPEN) || + if (!it_disposition(itp, DISP_OPEN_OPEN) || it_open_error(DISP_OPEN_OPEN, itp)) GOTO(out, rc); ll_release_openhandle(file->f_dentry, itp); - GOTO(out_stale, rc); + GOTO(out, rc); } if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) { rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp); - CERROR("lock enqueue: err: %d\n", rc); + CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc); GOTO(out, rc); } - if (itp->d.lustre.it_lock_mode) + 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); + &itp->d.lustre.it_lock_handle, + file->f_dentry->d_inode, NULL); - rc = ll_prep_inode(&file->f_dentry->d_inode, req, DLM_REPLY_REC_OFF, - NULL); out: ptlrpc_req_finished(itp->d.lustre.it_data); - -out_stale: it_clear_disposition(itp, DISP_ENQ_COMPLETE); ll_intent_drop_lock(itp); RETURN(rc); } +/** + * Assign an obtained @ioepoch to client's inode. No lock is needed, MDS does + * not believe attributes if a few ioepoch holders exist. Attributes for + * previous ioepoch if new one is opened are also skipped by MDS. + */ +void ll_ioepoch_open(struct ll_inode_info *lli, __u64 ioepoch) +{ + if (ioepoch && lli->lli_ioepoch != ioepoch) { + lli->lli_ioepoch = ioepoch; + CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n", + ioepoch, PFID(&lli->lli_fid)); + } +} + static int ll_och_fill(struct obd_export *md_exp, struct ll_inode_info *lli, struct lookup_intent *it, struct obd_client_handle *och) { @@ -385,15 +425,14 @@ static int ll_och_fill(struct obd_export *md_exp, struct ll_inode_info *lli, LASSERT(och); - body = lustre_msg_buf(req->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); /* reply already checked out */ - LASSERT_REPSWABBED(req, DLM_REPLY_REC_OFF); /* and swabbed in md_enqueue */ memcpy(&och->och_fh, &body->handle, sizeof(body->handle)); och->och_magic = OBD_CLIENT_HANDLE_MAGIC; och->och_fid = lli->lli_fid; och->och_flags = it->it_flags; - lli->lli_ioepoch = body->ioepoch; + ll_ioepoch_open(lli, body->ioepoch); return md_set_open_replay_data(md_exp, och, req); } @@ -418,15 +457,11 @@ int ll_local_open(struct file *file, struct lookup_intent *it, if (rc) RETURN(rc); - body = lustre_msg_buf(req->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body)); - + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); if ((it->it_flags & FMODE_WRITE) && (body->valid & OBD_MD_FLSIZE)) - { CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n", lli->lli_ioepoch, PFID(&lli->lli_fid)); - } } LUSTRE_FPRIVATE(file) = fd; @@ -460,17 +495,13 @@ int ll_file_open(struct inode *inode, struct file *file) struct obd_client_handle **och_p; __u64 *och_usecount; struct ll_file_data *fd; - int rc = 0; + int rc = 0, opendir_set = 0; ENTRY; CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), flags %o\n", inode->i_ino, inode->i_generation, inode, file->f_flags); - /* don't do anything for / */ - if (inode->i_sb->s_root == file->f_dentry) - RETURN(0); - -#ifdef LUSTRE_KERNEL_VERSION +#ifdef HAVE_VFS_INTENT_PATCHES it = file->f_it; #else it = file->private_data; /* XXX: compat macro */ @@ -481,7 +512,18 @@ int ll_file_open(struct inode *inode, struct file *file) if (fd == NULL) RETURN(-ENOMEM); - /* don't do anything for / */ + fd->fd_file = file; + if (S_ISDIR(inode->i_mode)) { + spin_lock(&lli->lli_lock); + if (lli->lli_opendir_key == NULL && lli->lli_opendir_pid == 0) { + LASSERT(lli->lli_sai == NULL); + lli->lli_opendir_key = fd; + lli->lli_opendir_pid = cfs_curproc_pid(); + opendir_set = 1; + } + spin_unlock(&lli->lli_lock); + } + if (inode->i_sb->s_root == file->f_dentry) { LUSTRE_FPRIVATE(file) = fd; RETURN(0); @@ -507,9 +549,16 @@ int ll_file_open(struct inode *inode, struct file *file) * already? XXX - NFS implications? */ oit.it_flags &= ~O_EXCL; + /* bug20584, if "it_flags" contains O_CREAT, the file will be + * created if necessary, then "IT_CREAT" should be set to keep + * consistent with it */ + if (oit.it_flags & O_CREAT) + oit.it_op |= IT_CREAT; + it = &oit; } +restart: /* Let's see if we have file open on MDS already. */ if (it->it_flags & FMODE_WRITE) { och_p = &lli->lli_mds_write_och; @@ -521,7 +570,7 @@ int ll_file_open(struct inode *inode, struct file *file) och_p = &lli->lli_mds_read_och; och_usecount = &lli->lli_open_fd_read_count; } - + down(&lli->lli_och_sem); if (*och_p) { /* Open handle is present */ if (it_disposition(it, DISP_OPEN_OPEN)) { @@ -529,36 +578,38 @@ int ll_file_open(struct inode *inode, struct file *file) let's close it somehow. This will decref request. */ rc = it_open_error(DISP_OPEN_OPEN, it); if (rc) { + up(&lli->lli_och_sem); ll_file_data_put(fd); - GOTO(out_och_free, rc); - } + GOTO(out_openerr, rc); + } ll_release_openhandle(file->f_dentry, it); - lprocfs_counter_incr(ll_i2sbi(inode)->ll_stats, + 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)--; up(&lli->lli_och_sem); ll_file_data_put(fd); - RETURN(rc); + GOTO(out_openerr, rc); } } else { LASSERT(*och_usecount == 0); - OBD_ALLOC(*och_p, sizeof (struct obd_client_handle)); - if (!*och_p) { - ll_file_data_put(fd); - GOTO(out_och_free, rc = -ENOMEM); - } - (*och_usecount)++; if (!it->d.lustre.it_disposition) { - it->it_flags |= O_CHECK_STALE; + /* 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 + result in a deadlock */ + up(&lli->lli_och_sem); + it->it_create_mode |= M_CHECK_STALE; rc = ll_intent_file_open(file, NULL, 0, it); - it->it_flags &= ~O_CHECK_STALE; + it->it_create_mode &= ~M_CHECK_STALE; if (rc) { ll_file_data_put(fd); - GOTO(out_och_free, rc); + GOTO(out_openerr, rc); } /* Got some error? Release the request */ @@ -566,10 +617,14 @@ int ll_file_open(struct inode *inode, struct file *file) req = it->d.lustre.it_data; ptlrpc_req_finished(req); } - md_set_lock_data(ll_i2sbi(inode)->ll_md_exp, - &it->d.lustre.it_lock_handle, - file->f_dentry->d_inode); + goto restart; + } + OBD_ALLOC(*och_p, sizeof (struct obd_client_handle)); + if (!*och_p) { + ll_file_data_put(fd); + 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 @@ -586,7 +641,6 @@ int ll_file_open(struct inode *inode, struct file *file) ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1); rc = ll_local_open(file, it, fd, *och_p); if (rc) { - up(&lli->lli_och_sem); ll_file_data_put(fd); GOTO(out_och_free, rc); } @@ -623,20 +677,23 @@ out_och_free: (*och_usecount)--; } up(&lli->lli_och_sem); +out_openerr: + if (opendir_set != 0) + ll_stop_statahead(inode, lli->lli_opendir_key); } return rc; } -/* Fills the obdo with the attributes for the inode defined by lsm */ -int ll_inode_getattr(struct inode *inode, struct obdo *obdo) +/* Fills the obdo with the attributes for the lsm */ +static int ll_lsm_getattr(struct lov_stripe_md *lsm, struct obd_export *exp, + struct obd_capa *capa, struct obdo *obdo, + __u64 ioepoch, int sync) { struct ptlrpc_request_set *set; - struct ll_inode_info *lli = ll_i2info(inode); - struct lov_stripe_md *lsm = lli->lli_smd; + struct obd_info oinfo = { { { 0 } } }; + int rc; - struct obd_info oinfo = { { { 0 } } }; - int rc; ENTRY; LASSERT(lsm != NULL); @@ -646,1024 +703,493 @@ int ll_inode_getattr(struct inode *inode, struct obdo *obdo) oinfo.oi_oa->o_id = lsm->lsm_object_id; oinfo.oi_oa->o_gr = lsm->lsm_object_gr; oinfo.oi_oa->o_mode = S_IFREG; + oinfo.oi_oa->o_ioepoch = ioepoch; oinfo.oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLSIZE | OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ | OBD_MD_FLATIME | OBD_MD_FLMTIME | OBD_MD_FLCTIME | - OBD_MD_FLGROUP; - oinfo.oi_capa = ll_mdscapa_get(inode); + OBD_MD_FLGROUP | OBD_MD_FLEPOCH; + oinfo.oi_capa = capa; + if (sync) { + oinfo.oi_oa->o_valid |= OBD_MD_FLFLAGS; + oinfo.oi_oa->o_flags |= OBD_FL_SRVLOCK; + } set = ptlrpc_prep_set(); if (set == NULL) { CERROR("can't allocate ptlrpc set\n"); rc = -ENOMEM; } else { - rc = obd_getattr_async(ll_i2dtexp(inode), &oinfo, set); + rc = obd_getattr_async(exp, &oinfo, set); if (rc == 0) rc = ptlrpc_set_wait(set); ptlrpc_set_destroy(set); } - capa_put(oinfo.oi_capa); - if (rc) - RETURN(rc); - - oinfo.oi_oa->o_valid &= (OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ | - OBD_MD_FLATIME | OBD_MD_FLMTIME | - OBD_MD_FLCTIME | OBD_MD_FLSIZE); - - obdo_refresh_inode(inode, oinfo.oi_oa, oinfo.oi_oa->o_valid); - CDEBUG(D_INODE, "objid "LPX64" size %Lu, blocks %lu, blksize %lu\n", - lli->lli_smd->lsm_object_id, inode->i_size, inode->i_blocks, - inode->i_blksize); - RETURN(0); + 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); + RETURN(rc); } -static inline void ll_remove_suid(struct inode *inode) +/** + * Performs the getattr on the inode and updates its fields. + * If @sync != 0, perform the getattr under the server-side lock. + */ +int ll_inode_getattr(struct inode *inode, struct obdo *obdo, + __u64 ioepoch, int sync) { - unsigned int mode; - - /* set S_IGID if S_IXGRP is set, and always set S_ISUID */ - mode = (inode->i_mode & S_IXGRP)*(S_ISGID/S_IXGRP) | S_ISUID; + struct ll_inode_info *lli = ll_i2info(inode); + struct obd_capa *capa = ll_mdscapa_get(inode); + int rc; + ENTRY; - /* was any of the uid bits set? */ - mode &= inode->i_mode; - if (mode && !capable(CAP_FSETID)) { - inode->i_mode &= ~mode; - // XXX careful here - we cannot change the size + rc = ll_lsm_getattr(lli->lli_smd, ll_i2dtexp(inode), + capa, obdo, ioepoch, sync); + capa_put(capa); + if (rc == 0) { + obdo_refresh_inode(inode, obdo, obdo->o_valid); + CDEBUG(D_INODE, + "objid "LPX64" size %Lu, 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)); } + RETURN(rc); } -static int ll_lock_to_stripe_offset(struct inode *inode, struct ldlm_lock *lock) +int ll_merge_lvb(struct inode *inode) { struct ll_inode_info *lli = ll_i2info(inode); - struct lov_stripe_md *lsm = lli->lli_smd; - struct obd_export *exp = ll_i2dtexp(inode); - struct { - char name[16]; - struct ldlm_lock *lock; - struct lov_stripe_md *lsm; - } key = { .name = "lock_to_stripe", .lock = lock, .lsm = lsm }; - __u32 stripe, vallen = sizeof(stripe); + struct ll_sb_info *sbi = ll_i2sbi(inode); + struct ost_lvb lvb; int rc; + ENTRY; - if (lsm->lsm_stripe_count == 1) - GOTO(check, stripe = 0); + ll_inode_size_lock(inode, 1); + inode_init_lvb(inode, &lvb); + rc = obd_merge_lvb(sbi->ll_dt_exp, lli->lli_smd, &lvb, 0); + i_size_write(inode, lvb.lvb_size); + inode->i_blocks = lvb.lvb_blocks; - /* get our offset in the lov */ - rc = obd_get_info(exp, sizeof(key), &key, &vallen, &stripe); - if (rc != 0) { - CERROR("obd_get_info: rc = %d\n", rc); - RETURN(rc); - } - LASSERT(stripe < lsm->lsm_stripe_count); + LTIME_S(inode->i_mtime) = lvb.lvb_mtime; + LTIME_S(inode->i_atime) = lvb.lvb_atime; + LTIME_S(inode->i_ctime) = lvb.lvb_ctime; + ll_inode_size_unlock(inode, 1); -check: - if (lsm->lsm_oinfo[stripe]->loi_id != lock->l_resource->lr_name.name[0]|| - lsm->lsm_oinfo[stripe]->loi_gr != lock->l_resource->lr_name.name[2]){ - LDLM_ERROR(lock, "resource doesn't match object "LPU64"/"LPU64, - lsm->lsm_oinfo[stripe]->loi_id, - lsm->lsm_oinfo[stripe]->loi_gr); - RETURN(-ELDLM_NO_LOCK_DATA); - } + RETURN(rc); +} + +int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm, + lstat_t *st) +{ + struct obdo obdo = { 0 }; + int rc; - RETURN(stripe); + rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, &obdo, 0, 0); + if (rc == 0) { + st->st_size = obdo.o_size; + st->st_blocks = obdo.o_blocks; + st->st_mtime = obdo.o_mtime; + st->st_atime = obdo.o_atime; + st->st_ctime = obdo.o_ctime; + } + return rc; } -/* Flush the page cache for an extent as its canceled. When we're on an LOV, - * we get a lock cancellation for each stripe, so we have to map the obd's - * region back onto the stripes in the file that it held. - * - * No one can dirty the extent until we've finished our work and they can - * enqueue another lock. The DLM protects us from ll_file_read/write here, - * but other kernel actors could have pages locked. - * - * Called with the DLM lock held. */ -void ll_pgcache_remove_extent(struct inode *inode, struct lov_stripe_md *lsm, - struct ldlm_lock *lock, __u32 stripe) +void ll_io_init(struct cl_io *io, const struct file *file, int write) { - ldlm_policy_data_t tmpex; - unsigned long start, end, count, skip, i, j; - struct page *page; - int rc, rc2, discard = lock->l_flags & LDLM_FL_DISCARD_DATA; - struct lustre_handle lockh; - ENTRY; + struct inode *inode = file->f_dentry->d_inode; - memcpy(&tmpex, &lock->l_policy_data, sizeof(tmpex)); - CDEBUG(D_INODE|D_PAGE, "inode %lu(%p) ["LPU64"->"LPU64"] size: %llu\n", - inode->i_ino, inode, tmpex.l_extent.start, tmpex.l_extent.end, - inode->i_size); - - /* our locks are page granular thanks to osc_enqueue, we invalidate the - * whole page. */ - if ((tmpex.l_extent.start & ~CFS_PAGE_MASK) != 0 || - ((tmpex.l_extent.end + 1) & ~CFS_PAGE_MASK) != 0) - LDLM_ERROR(lock, "lock not aligned on PAGE_SIZE %lu", - CFS_PAGE_SIZE); - LASSERT((tmpex.l_extent.start & ~CFS_PAGE_MASK) == 0); - LASSERT(((tmpex.l_extent.end + 1) & ~CFS_PAGE_MASK) == 0); - - count = ~0; - skip = 0; - start = tmpex.l_extent.start >> CFS_PAGE_SHIFT; - end = tmpex.l_extent.end >> CFS_PAGE_SHIFT; - if (lsm->lsm_stripe_count > 1) { - count = lsm->lsm_stripe_size >> CFS_PAGE_SHIFT; - skip = (lsm->lsm_stripe_count - 1) * count; - start += start/count * skip + stripe * count; - if (end != ~0) - end += end/count * skip + stripe * count; - } - if (end < tmpex.l_extent.end >> CFS_PAGE_SHIFT) - end = ~0; - - i = inode->i_size ? (__u64)(inode->i_size - 1) >> CFS_PAGE_SHIFT : 0; - if (i < end) - end = i; - - CDEBUG(D_INODE|D_PAGE, "walking page indices start: %lu j: %lu " - "count: %lu skip: %lu end: %lu%s\n", start, start % count, - count, skip, end, discard ? " (DISCARDING)" : ""); - - /* walk through the vmas on the inode and tear down mmaped pages that - * intersect with the lock. this stops immediately if there are no - * mmap()ed regions of the file. This is not efficient at all and - * should be short lived. We'll associate mmap()ed pages with the lock - * and will be able to find them directly */ - for (i = start; i <= end; i += (j + skip)) { - j = min(count - (i % count), end - i + 1); - LASSERT(j > 0); - LASSERT(inode->i_mapping); - if (ll_teardown_mmaps(inode->i_mapping, - (__u64)i << CFS_PAGE_SHIFT, - ((__u64)(i+j) << CFS_PAGE_SHIFT) - 1) ) - break; + 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); + io->ci_obj = ll_i2info(inode)->lli_clob; + io->ci_lockreq = CILR_MAYBE; + if (ll_file_nolock(file)) { + io->ci_lockreq = CILR_NEVER; + io->ci_no_srvlock = 1; + } else if (file->f_flags & O_APPEND) { + io->ci_lockreq = CILR_MANDATORY; } +} - /* this is the simplistic implementation of page eviction at - * cancelation. It is careful to get races with other page - * lockers handled correctly. fixes from bug 20 will make it - * more efficient by associating locks with pages and with - * batching writeback under the lock explicitly. */ - for (i = start, j = start % count; i <= end; - j++, i++, tmpex.l_extent.start += CFS_PAGE_SIZE) { - if (j == count) { - CDEBUG(D_PAGE, "skip index %lu to %lu\n", i, i + skip); - i += skip; - j = 0; - if (i > end) - break; - } - LASSERTF(tmpex.l_extent.start< lock->l_policy_data.l_extent.end, - LPU64" >= "LPU64" start %lu i %lu end %lu\n", - tmpex.l_extent.start, lock->l_policy_data.l_extent.end, - start, i, end); +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; + ENTRY; - if (!mapping_has_pages(inode->i_mapping)) { - CDEBUG(D_INODE|D_PAGE, "nothing left\n"); - break; - } + io = &ccc_env_info(env)->cti_io; + ll_io_init(io, file, iot == CIT_WRITE); - cond_resched(); + 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; - page = find_get_page(inode->i_mapping, i); - if (page == NULL) - continue; - LL_CDEBUG_PAGE(D_PAGE, page, "lock page idx %lu ext "LPU64"\n", - i, tmpex.l_extent.start); - lock_page(page); - - /* page->mapping to check with racing against teardown */ - if (!discard && clear_page_dirty_for_io(page)) { - rc = ll_call_writepage(inode, page); - if (rc != 0) - CERROR("writepage of page %p failed: %d\n", - page, rc); - /* either waiting for io to complete or reacquiring - * the lock that the failed writepage released */ - lock_page(page); - } + cio->cui_fd = LUSTRE_FPRIVATE(file); + vio->cui_io_subtype = args->via_io_subtype; - tmpex.l_extent.end = tmpex.l_extent.start + CFS_PAGE_SIZE - 1; - /* check to see if another DLM lock covers this page b=2765 */ - rc2 = ldlm_lock_match(lock->l_resource->lr_namespace, - LDLM_FL_BLOCK_GRANTED|LDLM_FL_CBPENDING | - LDLM_FL_TEST_LOCK, - &lock->l_resource->lr_name, LDLM_EXTENT, - &tmpex, LCK_PR | LCK_PW, &lockh); - - if (rc2 <= 0 && page->mapping != NULL) { - struct ll_async_page *llap = llap_cast_private(page); - /* checking again to account for writeback's - * lock_page() */ - LL_CDEBUG_PAGE(D_PAGE, page, "truncating\n"); - if (llap) - ll_ra_accounting(llap, inode->i_mapping); - ll_truncate_complete_page(page); + switch (vio->cui_io_subtype) { + case IO_NORMAL: + cio->cui_iov = args->u.normal.via_iov; + cio->cui_nrsegs = args->u.normal.via_nrsegs; +#ifndef HAVE_FILE_WRITEV + cio->cui_iocb = args->u.normal.via_iocb; +#endif + if ((iot == CIT_WRITE) && + !(cio->cui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) { + down(&lli->lli_write_sem); + write_sem_locked = 1; + } + break; + case IO_SENDFILE: + vio->u.sendfile.cui_actor = args->u.sendfile.via_actor; + vio->u.sendfile.cui_target = args->u.sendfile.via_target; + break; + case IO_SPLICE: + vio->u.splice.cui_pipe = args->u.splice.via_pipe; + vio->u.splice.cui_flags = args->u.splice.via_flags; + break; + default: + CERROR("Unknow IO type - %u\n", vio->cui_io_subtype); + LBUG(); } - unlock_page(page); - page_cache_release(page); - } - LASSERTF(tmpex.l_extent.start <= - (lock->l_policy_data.l_extent.end == ~0ULL ? ~0ULL : - lock->l_policy_data.l_extent.end + 1), - "loop too long "LPU64" > "LPU64" start %lu i %lu end %lu\n", - tmpex.l_extent.start, lock->l_policy_data.l_extent.end, - start, i, end); - EXIT; + result = cl_io_loop(env, io); + if (write_sem_locked) + up(&lli->lli_write_sem); + } else { + /* cl_io_rw_init() handled IO */ + result = io->ci_result; + } + + if (io->ci_nob > 0) { + result = io->ci_nob; + *ppos = io->u.ci_wr.wr.crw_pos; + } + cl_io_fini(env, io); + RETURN(result); } -static int ll_extent_lock_callback(struct ldlm_lock *lock, - struct ldlm_lock_desc *new, void *data, - int flag) + +/* + * XXX: exact copy from kernel code (__generic_file_aio_write_nolock) + */ +static int ll_file_get_iov_count(const struct iovec *iov, + unsigned long *nr_segs, size_t *count) { - struct lustre_handle lockh = { 0 }; - int rc; - ENTRY; + size_t cnt = 0; + unsigned long seg; - if ((unsigned long)data > 0 && (unsigned long)data < 0x1000) { - LDLM_ERROR(lock, "cancelling lock with bad data %p", data); - LBUG(); - } + for (seg = 0; seg < *nr_segs; seg++) { + const struct iovec *iv = &iov[seg]; - switch (flag) { - case LDLM_CB_BLOCKING: - ldlm_lock2handle(lock, &lockh); - rc = ldlm_cli_cancel(&lockh); - if (rc != ELDLM_OK) - CERROR("ldlm_cli_cancel failed: %d\n", rc); - break; - case LDLM_CB_CANCELING: { - struct inode *inode; - struct ll_inode_info *lli; - struct lov_stripe_md *lsm; - int stripe; - __u64 kms; - - /* This lock wasn't granted, don't try to evict pages */ - if (lock->l_req_mode != lock->l_granted_mode) - RETURN(0); - - inode = ll_inode_from_lock(lock); - if (inode == NULL) - RETURN(0); - lli = ll_i2info(inode); - if (lli == NULL) - goto iput; - if (lli->lli_smd == NULL) - goto iput; - lsm = lli->lli_smd; - - stripe = ll_lock_to_stripe_offset(inode, lock); - if (stripe < 0) - goto iput; - - ll_pgcache_remove_extent(inode, lsm, lock, stripe); - - lov_stripe_lock(lsm); - lock_res_and_lock(lock); - kms = ldlm_extent_shift_kms(lock, - lsm->lsm_oinfo[stripe]->loi_kms); - - if (lsm->lsm_oinfo[stripe]->loi_kms != kms) - LDLM_DEBUG(lock, "updating kms from "LPU64" to "LPU64, - lsm->lsm_oinfo[stripe]->loi_kms, kms); - lsm->lsm_oinfo[stripe]->loi_kms = kms; - unlock_res_and_lock(lock); - lov_stripe_unlock(lsm); - iput: - iput(inode); + /* + * If any segment has a negative length, or the cumulative + * length ever wraps negative then return -EINVAL. + */ + cnt += iv->iov_len; + if (unlikely((ssize_t)(cnt|iv->iov_len) < 0)) + return -EINVAL; + if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len)) + continue; + if (seg == 0) + return -EFAULT; + *nr_segs = seg; + cnt -= iv->iov_len; /* This segment is no good */ break; } - default: - LBUG(); - } - - RETURN(0); + *count = cnt; + return 0; } -#if 0 -int ll_async_completion_ast(struct ldlm_lock *lock, int flags, void *data) +#ifdef HAVE_FILE_READV +static ssize_t ll_file_readv(struct file *file, const struct iovec *iov, + unsigned long nr_segs, loff_t *ppos) { - /* XXX ALLOCATE - 160 bytes */ - struct inode *inode = ll_inode_from_lock(lock); - struct ll_inode_info *lli = ll_i2info(inode); - struct lustre_handle lockh = { 0 }; - struct ost_lvb *lvb; - int stripe; + struct lu_env *env; + struct vvp_io_args *args; + size_t count; + ssize_t result; + int refcheck; ENTRY; - if (flags & (LDLM_FL_BLOCK_WAIT | LDLM_FL_BLOCK_GRANTED | - LDLM_FL_BLOCK_CONV)) { - LBUG(); /* not expecting any blocked async locks yet */ - LDLM_DEBUG(lock, "client-side async enqueue returned a blocked " - "lock, returning"); - ldlm_lock_dump(D_OTHER, lock, 0); - ldlm_reprocess_all(lock->l_resource); - RETURN(0); - } - - LDLM_DEBUG(lock, "client-side async enqueue: granted/glimpsed"); - - stripe = ll_lock_to_stripe_offset(inode, lock); - if (stripe < 0) - goto iput; + result = ll_file_get_iov_count(iov, &nr_segs, &count); + if (result) + RETURN(result); - if (lock->l_lvb_len) { - struct lov_stripe_md *lsm = lli->lli_smd; - __u64 kms; - lvb = lock->l_lvb_data; - lsm->lsm_oinfo[stripe].loi_rss = lvb->lvb_size; - - lock_res_and_lock(lock); - ll_inode_size_lock(inode, 1); - kms = MAX(lsm->lsm_oinfo[stripe].loi_kms, lvb->lvb_size); - kms = ldlm_extent_shift_kms(NULL, kms); - if (lsm->lsm_oinfo[stripe].loi_kms != kms) - LDLM_DEBUG(lock, "updating kms from "LPU64" to "LPU64, - lsm->lsm_oinfo[stripe].loi_kms, kms); - lsm->lsm_oinfo[stripe].loi_kms = kms; - ll_inode_size_unlock(inode, 1); - unlock_res_and_lock(lock); - } + env = cl_env_get(&refcheck); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); -iput: - iput(inode); - wake_up(&lock->l_waitq); + args = vvp_env_args(env, IO_NORMAL); + args->u.normal.via_iov = (struct iovec *)iov; + args->u.normal.via_nrsegs = nr_segs; - ldlm_lock2handle(lock, &lockh); - ldlm_lock_decref(&lockh, LCK_PR); - RETURN(0); + result = ll_file_io_generic(env, args, file, CIT_READ, ppos, count); + cl_env_put(env, &refcheck); + RETURN(result); } -#endif -static int ll_glimpse_callback(struct ldlm_lock *lock, void *reqp) +static ssize_t ll_file_read(struct file *file, char *buf, size_t count, + loff_t *ppos) { - struct ptlrpc_request *req = reqp; - struct inode *inode = ll_inode_from_lock(lock); - struct ll_inode_info *lli; - struct lov_stripe_md *lsm; - struct ost_lvb *lvb; - int rc, stripe; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*lvb) }; + struct lu_env *env; + struct iovec *local_iov; + ssize_t result; + int refcheck; ENTRY; - if (inode == NULL) - GOTO(out, rc = -ELDLM_NO_LOCK_DATA); - lli = ll_i2info(inode); - if (lli == NULL) - GOTO(iput, rc = -ELDLM_NO_LOCK_DATA); - lsm = lli->lli_smd; - if (lsm == NULL) - GOTO(iput, rc = -ELDLM_NO_LOCK_DATA); + env = cl_env_get(&refcheck); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); - /* First, find out which stripe index this lock corresponds to. */ - stripe = ll_lock_to_stripe_offset(inode, lock); - if (stripe < 0) - GOTO(iput, rc = -ELDLM_NO_LOCK_DATA); + local_iov = &vvp_env_info(env)->vti_local_iov; + local_iov->iov_base = (void __user *)buf; + local_iov->iov_len = count; + result = ll_file_readv(file, local_iov, 1, ppos); + cl_env_put(env, &refcheck); + RETURN(result); +} - rc = lustre_pack_reply(req, 2, size, NULL); - if (rc) { - CERROR("lustre_pack_reply: %d\n", rc); - GOTO(iput, rc); - } +#else +static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov, + unsigned long nr_segs, loff_t pos) +{ + struct lu_env *env; + struct vvp_io_args *args; + size_t count; + ssize_t result; + int refcheck; + ENTRY; - lvb = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*lvb)); - lvb->lvb_size = lli->lli_smd->lsm_oinfo[stripe]->loi_kms; - lvb->lvb_mtime = LTIME_S(inode->i_mtime); - lvb->lvb_atime = LTIME_S(inode->i_atime); - lvb->lvb_ctime = LTIME_S(inode->i_ctime); + result = ll_file_get_iov_count(iov, &nr_segs, &count); + if (result) + RETURN(result); - LDLM_DEBUG(lock, "i_size: %llu -> stripe number %u -> kms "LPU64 - " atime "LPU64", mtime "LPU64", ctime "LPU64, - inode->i_size, stripe, lvb->lvb_size, lvb->lvb_mtime, - lvb->lvb_atime, lvb->lvb_ctime); - iput: - iput(inode); + env = cl_env_get(&refcheck); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); - out: - /* These errors are normal races, so we don't want to fill the console - * with messages by calling ptlrpc_error() */ - if (rc == -ELDLM_NO_LOCK_DATA) - lustre_pack_reply(req, 1, NULL, NULL); + args = vvp_env_args(env, IO_NORMAL); + args->u.normal.via_iov = (struct iovec *)iov; + args->u.normal.via_nrsegs = nr_segs; + args->u.normal.via_iocb = iocb; - req->rq_status = rc; - return rc; + result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_READ, + &iocb->ki_pos, count); + cl_env_put(env, &refcheck); + RETURN(result); } -static void ll_merge_lvb(struct inode *inode) +static ssize_t ll_file_read(struct file *file, char *buf, size_t count, + loff_t *ppos) { - struct ll_inode_info *lli = ll_i2info(inode); - struct ll_sb_info *sbi = ll_i2sbi(inode); - struct ost_lvb lvb; + struct lu_env *env; + struct iovec *local_iov; + struct kiocb *kiocb; + ssize_t result; + int refcheck; ENTRY; - ll_inode_size_lock(inode, 1); - inode_init_lvb(inode, &lvb); - obd_merge_lvb(sbi->ll_dt_exp, lli->lli_smd, &lvb, 0); - inode->i_size = lvb.lvb_size; - inode->i_blocks = lvb.lvb_blocks; - LTIME_S(inode->i_mtime) = lvb.lvb_mtime; - LTIME_S(inode->i_atime) = lvb.lvb_atime; - LTIME_S(inode->i_ctime) = lvb.lvb_ctime; - ll_inode_size_unlock(inode, 1); - EXIT; -} - -int ll_local_size(struct inode *inode) -{ - ldlm_policy_data_t policy = { .l_extent = { 0, OBD_OBJECT_EOF } }; - struct ll_inode_info *lli = ll_i2info(inode); - struct ll_sb_info *sbi = ll_i2sbi(inode); - struct lustre_handle lockh = { 0 }; - int flags = 0; - int rc; - ENTRY; + env = cl_env_get(&refcheck); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); - if (lli->lli_smd->lsm_stripe_count == 0) - RETURN(0); + local_iov = &vvp_env_info(env)->vti_local_iov; + kiocb = &vvp_env_info(env)->vti_kiocb; + local_iov->iov_base = (void __user *)buf; + local_iov->iov_len = count; + init_sync_kiocb(kiocb, file); + kiocb->ki_pos = *ppos; + kiocb->ki_left = count; - rc = obd_match(sbi->ll_dt_exp, lli->lli_smd, LDLM_EXTENT, - &policy, LCK_PR | LCK_PW, &flags, inode, &lockh); - if (rc < 0) - RETURN(rc); - else if (rc == 0) - RETURN(-ENODATA); + result = ll_file_aio_read(kiocb, local_iov, 1, kiocb->ki_pos); + *ppos = kiocb->ki_pos; - ll_merge_lvb(inode); - obd_cancel(sbi->ll_dt_exp, lli->lli_smd, LCK_PR | LCK_PW, &lockh); - RETURN(0); + cl_env_put(env, &refcheck); + RETURN(result); } +#endif -int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm, - lstat_t *st) +/* + * Write to a file (through the page cache). + */ +#ifdef HAVE_FILE_WRITEV +static ssize_t ll_file_writev(struct file *file, const struct iovec *iov, + unsigned long nr_segs, loff_t *ppos) { - struct lustre_handle lockh = { 0 }; - struct obd_enqueue_info einfo = { 0 }; - struct obd_info oinfo = { { { 0 } } }; - struct ost_lvb lvb; - int rc; - + struct lu_env *env; + struct vvp_io_args *args; + size_t count; + ssize_t result; + int refcheck; ENTRY; - einfo.ei_type = LDLM_EXTENT; - einfo.ei_mode = LCK_PR; - einfo.ei_flags = LDLM_FL_HAS_INTENT; - einfo.ei_cb_bl = ll_extent_lock_callback; - einfo.ei_cb_cp = ldlm_completion_ast; - einfo.ei_cb_gl = ll_glimpse_callback; - einfo.ei_cbdata = NULL; + result = ll_file_get_iov_count(iov, &nr_segs, &count); + if (result) + RETURN(result); - oinfo.oi_policy.l_extent.end = OBD_OBJECT_EOF; - oinfo.oi_lockh = &lockh; - oinfo.oi_md = lsm; + env = cl_env_get(&refcheck); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); - rc = obd_enqueue_rqset(sbi->ll_dt_exp, &oinfo, &einfo); - if (rc == -ENOENT) - RETURN(rc); - if (rc != 0) { - CERROR("obd_enqueue returned rc %d, " - "returning -EIO\n", rc); - RETURN(rc > 0 ? -EIO : rc); - } - - lov_stripe_lock(lsm); - memset(&lvb, 0, sizeof(lvb)); - obd_merge_lvb(sbi->ll_dt_exp, lsm, &lvb, 0); - st->st_size = lvb.lvb_size; - st->st_blocks = lvb.lvb_blocks; - st->st_mtime = lvb.lvb_mtime; - st->st_atime = lvb.lvb_atime; - st->st_ctime = lvb.lvb_ctime; - lov_stripe_unlock(lsm); + args = vvp_env_args(env, IO_NORMAL); + args->u.normal.via_iov = (struct iovec *)iov; + args->u.normal.via_nrsegs = nr_segs; - RETURN(rc); + result = ll_file_io_generic(env, args, file, CIT_WRITE, ppos, count); + cl_env_put(env, &refcheck); + RETURN(result); } -/* NB: obd_merge_lvb will prefer locally cached writes if they extend the - * file (because it prefers KMS over RSS when larger) */ -int ll_glimpse_size(struct inode *inode, int ast_flags) +static ssize_t ll_file_write(struct file *file, const char *buf, size_t count, + loff_t *ppos) { - struct ll_inode_info *lli = ll_i2info(inode); - struct ll_sb_info *sbi = ll_i2sbi(inode); - struct lustre_handle lockh = { 0 }; - struct obd_enqueue_info einfo = { 0 }; - struct obd_info oinfo = { { { 0 } } }; - int rc; + struct lu_env *env; + struct iovec *local_iov; + ssize_t result; + int refcheck; ENTRY; - if (lli->lli_flags & LLIF_MDS_SIZE_LOCK) - RETURN(0); + env = cl_env_get(&refcheck); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); - CDEBUG(D_DLMTRACE, "Glimpsing inode %lu\n", inode->i_ino); + local_iov = &vvp_env_info(env)->vti_local_iov; + local_iov->iov_base = (void __user *)buf; + local_iov->iov_len = count; - if (!lli->lli_smd) { - CDEBUG(D_DLMTRACE, "No objects for inode %lu\n", inode->i_ino); - RETURN(0); - } + result = ll_file_writev(file, local_iov, 1, ppos); + cl_env_put(env, &refcheck); + RETURN(result); +} - /* NOTE: this looks like DLM lock request, but it may not be one. Due - * to LDLM_FL_HAS_INTENT flag, this is glimpse request, that - * won't revoke any conflicting DLM locks held. Instead, - * ll_glimpse_callback() will be called on each client - * holding a DLM lock against this file, and resulting size - * will be returned for each stripe. DLM lock on [0, EOF] is - * acquired only if there were no conflicting locks. */ - einfo.ei_type = LDLM_EXTENT; - einfo.ei_mode = LCK_PR; - einfo.ei_flags = ast_flags | LDLM_FL_HAS_INTENT; - einfo.ei_cb_bl = ll_extent_lock_callback; - einfo.ei_cb_cp = ldlm_completion_ast; - einfo.ei_cb_gl = ll_glimpse_callback; - einfo.ei_cbdata = inode; - - oinfo.oi_policy.l_extent.end = OBD_OBJECT_EOF; - oinfo.oi_lockh = &lockh; - oinfo.oi_md = lli->lli_smd; - - rc = obd_enqueue_rqset(sbi->ll_dt_exp, &oinfo, &einfo); - if (rc == -ENOENT) - RETURN(rc); - if (rc != 0) { - CERROR("obd_enqueue returned rc %d, returning -EIO\n", rc); - RETURN(rc > 0 ? -EIO : rc); - } +#else /* AIO stuff */ +static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov, + unsigned long nr_segs, loff_t pos) +{ + struct lu_env *env; + struct vvp_io_args *args; + size_t count; + ssize_t result; + int refcheck; + ENTRY; - ll_merge_lvb(inode); + result = ll_file_get_iov_count(iov, &nr_segs, &count); + if (result) + RETURN(result); - CDEBUG(D_DLMTRACE, "glimpse: size: %llu, blocks: %lu\n", - inode->i_size, inode->i_blocks); + env = cl_env_get(&refcheck); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); - RETURN(rc); + args = vvp_env_args(env, IO_NORMAL); + args->u.normal.via_iov = (struct iovec *)iov; + args->u.normal.via_nrsegs = nr_segs; + args->u.normal.via_iocb = iocb; + + result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_WRITE, + &iocb->ki_pos, count); + cl_env_put(env, &refcheck); + RETURN(result); } -int ll_extent_lock(struct ll_file_data *fd, struct inode *inode, - struct lov_stripe_md *lsm, int mode, - ldlm_policy_data_t *policy, struct lustre_handle *lockh, - int ast_flags) +static ssize_t ll_file_write(struct file *file, const char *buf, size_t count, + loff_t *ppos) { - struct ll_sb_info *sbi = ll_i2sbi(inode); - struct ost_lvb lvb; - struct obd_enqueue_info einfo = { 0 }; - struct obd_info oinfo = { { { 0 } } }; - int rc; + struct lu_env *env; + struct iovec *local_iov; + struct kiocb *kiocb; + ssize_t result; + int refcheck; ENTRY; - LASSERT(!lustre_handle_is_used(lockh)); - LASSERT(lsm != NULL); - - /* don't drop the mmapped file to LRU */ - if (mapping_mapped(inode->i_mapping)) - ast_flags |= LDLM_FL_NO_LRU; + env = cl_env_get(&refcheck); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); - /* XXX phil: can we do this? won't it screw the file size up? */ - if ((fd && (fd->fd_flags & LL_FILE_IGNORE_LOCK)) || - (sbi->ll_flags & LL_SBI_NOLCK)) - RETURN(0); + local_iov = &vvp_env_info(env)->vti_local_iov; + kiocb = &vvp_env_info(env)->vti_kiocb; + local_iov->iov_base = (void __user *)buf; + local_iov->iov_len = count; + init_sync_kiocb(kiocb, file); + kiocb->ki_pos = *ppos; + kiocb->ki_left = count; - CDEBUG(D_DLMTRACE, "Locking inode %lu, start "LPU64" end "LPU64"\n", - inode->i_ino, policy->l_extent.start, policy->l_extent.end); + result = ll_file_aio_write(kiocb, local_iov, 1, kiocb->ki_pos); + *ppos = kiocb->ki_pos; - einfo.ei_type = LDLM_EXTENT; - einfo.ei_mode = mode; - einfo.ei_flags = ast_flags; - einfo.ei_cb_bl = ll_extent_lock_callback; - einfo.ei_cb_cp = ldlm_completion_ast; - einfo.ei_cb_gl = ll_glimpse_callback; - einfo.ei_cbdata = inode; + cl_env_put(env, &refcheck); + RETURN(result); +} +#endif - oinfo.oi_policy = *policy; - oinfo.oi_lockh = lockh; - oinfo.oi_md = lsm; - rc = obd_enqueue(sbi->ll_dt_exp, &oinfo, &einfo); - *policy = oinfo.oi_policy; - if (rc > 0) - rc = -EIO; +#ifdef HAVE_KERNEL_SENDFILE +/* + * Send file content (through pagecache) somewhere with helper + */ +static ssize_t ll_file_sendfile(struct file *in_file, loff_t *ppos,size_t count, + read_actor_t actor, void *target) +{ + struct lu_env *env; + struct vvp_io_args *args; + ssize_t result; + int refcheck; + ENTRY; - ll_inode_size_lock(inode, 1); - inode_init_lvb(inode, &lvb); - obd_merge_lvb(sbi->ll_dt_exp, lsm, &lvb, 1); - - if (policy->l_extent.start == 0 && - policy->l_extent.end == OBD_OBJECT_EOF) { - /* vmtruncate()->ll_truncate() first sets the i_size and then - * the kms under both a DLM lock and the - * ll_inode_size_lock(). If we don't get the - * ll_inode_size_lock() here we can match the DLM lock and - * reset i_size from the kms before the truncating path has - * updated the kms. generic_file_write can then trust the - * stale i_size when doing appending writes and effectively - * cancel the result of the truncate. Getting the - * ll_inode_size_lock() after the enqueue maintains the DLM - * -> ll_inode_size_lock() acquiring order. */ - inode->i_size = lvb.lvb_size; - CDEBUG(D_INODE, "inode=%lu, updating i_size %llu\n", - inode->i_ino, inode->i_size); - } + env = cl_env_get(&refcheck); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); - if (rc == 0) { - LTIME_S(inode->i_mtime) = lvb.lvb_mtime; - LTIME_S(inode->i_atime) = lvb.lvb_atime; - LTIME_S(inode->i_ctime) = lvb.lvb_ctime; - } - ll_inode_size_unlock(inode, 1); + args = vvp_env_args(env, IO_SENDFILE); + args->u.sendfile.via_target = target; + args->u.sendfile.via_actor = actor; - RETURN(rc); + result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count); + cl_env_put(env, &refcheck); + RETURN(result); } +#endif -int ll_extent_unlock(struct ll_file_data *fd, struct inode *inode, - struct lov_stripe_md *lsm, int mode, - struct lustre_handle *lockh) +#ifdef HAVE_KERNEL_SPLICE_READ +/* + * Send file content (through pagecache) somewhere with helper + */ +static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos, + struct pipe_inode_info *pipe, size_t count, + unsigned int flags) { - struct ll_sb_info *sbi = ll_i2sbi(inode); - int rc; + struct lu_env *env; + struct vvp_io_args *args; + ssize_t result; + int refcheck; ENTRY; - /* XXX phil: can we do this? won't it screw the file size up? */ - if ((fd && (fd->fd_flags & LL_FILE_IGNORE_LOCK)) || - (sbi->ll_flags & LL_SBI_NOLCK)) - RETURN(0); + env = cl_env_get(&refcheck); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); - rc = obd_cancel(sbi->ll_dt_exp, lsm, mode, lockh); + args = vvp_env_args(env, IO_SPLICE); + args->u.splice.via_pipe = pipe; + args->u.splice.via_flags = flags; - RETURN(rc); + result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count); + cl_env_put(env, &refcheck); + RETURN(result); } - -static ssize_t ll_file_read(struct file *file, char *buf, size_t count, - loff_t *ppos) -{ - 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 ll_sb_info *sbi = ll_i2sbi(inode); - struct ll_lock_tree tree; - struct ll_lock_tree_node *node; - struct ost_lvb lvb; - struct ll_ra_read bead; - int rc, ra = 0; - loff_t end; - ssize_t retval, chunk, sum = 0; - - __u64 kms; - ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),size="LPSZ",offset=%Ld\n", - inode->i_ino, inode->i_generation, inode, count, *ppos); - /* "If nbyte is 0, read() will return 0 and have no other results." - * -- Single Unix Spec */ - if (count == 0) - RETURN(0); - - ll_stats_ops_tally(sbi, LPROC_LL_READ_BYTES, count); - - if (!lsm) { - /* Read on file with no objects should return zero-filled - * buffers up to file size (we can get non-zero sizes with - * mknod + truncate, then opening file for read. This is a - * common pattern in NFS case, it seems). Bug 6243 */ - int notzeroed; - /* Since there are no objects on OSTs, we have nothing to get - * lock on and so we are forced to access inode->i_size - * unguarded */ - - /* Read beyond end of file */ - if (*ppos >= inode->i_size) - RETURN(0); - - if (count > inode->i_size - *ppos) - count = inode->i_size - *ppos; - /* Make sure to correctly adjust the file pos pointer for - * EFAULT case */ - notzeroed = clear_user(buf, count); - count -= notzeroed; - *ppos += count; - if (!count) - RETURN(-EFAULT); - RETURN(count); - } - -repeat: - if (sbi->ll_max_rw_chunk != 0) { - /* first, let's know the end of the current stripe */ - end = *ppos; - obd_extent_calc(sbi->ll_dt_exp, lsm, OBD_CALC_STRIPE_END, - (obd_off *)&end); - - /* correct, the end is beyond the request */ - if (end > *ppos + count - 1) - end = *ppos + count - 1; - - /* and chunk shouldn't be too large even if striping is wide */ - if (end - *ppos > sbi->ll_max_rw_chunk) - end = *ppos + sbi->ll_max_rw_chunk - 1; - } else { - end = *ppos + count - 1; - } - - node = ll_node_from_inode(inode, *ppos, end, LCK_PR); - tree.lt_fd = LUSTRE_FPRIVATE(file); - rc = ll_tree_lock(&tree, node, buf, count, - file->f_flags & O_NONBLOCK ? LDLM_FL_BLOCK_NOWAIT :0); - if (rc != 0) - GOTO(out, retval = rc); - - ll_inode_size_lock(inode, 1); - /* - * Consistency guarantees: following possibilities exist for the - * relation between region being read and real file size at this - * moment: - * - * (A): the region is completely inside of the file; - * - * (B-x): x bytes of region are inside of the file, the rest is - * outside; - * - * (C): the region is completely outside of the file. - * - * This classification is stable under DLM lock acquired by - * ll_tree_lock() above, because to change class, other client has to - * take DLM lock conflicting with our lock. Also, any updates to - * ->i_size by other threads on this client are serialized by - * ll_inode_size_lock(). This guarantees that short reads are handled - * correctly in the face of concurrent writes and truncates. - */ - inode_init_lvb(inode, &lvb); - obd_merge_lvb(sbi->ll_dt_exp, lsm, &lvb, 1); - kms = lvb.lvb_size; - if (*ppos + count - 1 > kms) { - /* A glimpse is necessary to determine whether we return a - * short read (B) or some zeroes at the end of the buffer (C) */ - ll_inode_size_unlock(inode, 1); - retval = ll_glimpse_size(inode, LDLM_FL_BLOCK_GRANTED); - if (retval) { - ll_tree_unlock(&tree); - goto out; - } - } else { - /* region is within kms and, hence, within real file size (A). - * We need to increase i_size to cover the read region so that - * generic_file_read() will do its job, but that doesn't mean - * the kms size is _correct_, it is only the _minimum_ size. - * If someone does a stat they will get the correct size which - * will always be >= the kms value here. b=11081 */ - if (inode->i_size < kms) - inode->i_size = kms; - ll_inode_size_unlock(inode, 1); - } - - chunk = end - *ppos + 1; - CDEBUG(D_INODE, "Read ino %lu, "LPSZ" bytes, offset %lld, i_size %llu\n", - inode->i_ino, chunk, *ppos, inode->i_size); - - /* turn off the kernel's read-ahead */ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) - file->f_ramax = 0; -#else - file->f_ra.ra_pages = 0; -#endif - /* initialize read-ahead window once per syscall */ - if (ra == 0) { - ra = 1; - bead.lrr_start = *ppos >> CFS_PAGE_SHIFT; - bead.lrr_count = (count + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT; - ll_ra_read_in(file, &bead); - } - - /* BUG: 5972 */ - file_accessed(file); - retval = generic_file_read(file, buf, chunk, ppos); - ll_rw_stats_tally(sbi, current->pid, file, count, 0); - - ll_tree_unlock(&tree); - - if (retval > 0) { - buf += retval; - count -= retval; - sum += retval; - if (retval == chunk && count > 0) - goto repeat; - } - - out: - if (ra != 0) - ll_ra_read_ex(file, &bead); - retval = (sum > 0) ? sum : retval; - RETURN(retval); -} - -/* - * Write to a file (through the page cache). - */ -static ssize_t ll_file_write(struct file *file, const char *buf, size_t count, - loff_t *ppos) -{ - struct inode *inode = file->f_dentry->d_inode; - struct ll_sb_info *sbi = ll_i2sbi(inode); - struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd; - struct ll_lock_tree tree; - struct ll_lock_tree_node *node; - loff_t maxbytes = ll_file_maxbytes(inode); - loff_t lock_start, lock_end, end; - ssize_t retval, chunk, sum = 0; - int rc; - ENTRY; - - CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),size="LPSZ",offset=%Ld\n", - inode->i_ino, inode->i_generation, inode, count, *ppos); - - SIGNAL_MASK_ASSERT(); /* XXX BUG 1511 */ - - /* POSIX, but surprised the VFS doesn't check this already */ - if (count == 0) - RETURN(0); - - /* If file was opened for LL_IOC_LOV_SETSTRIPE but the ioctl wasn't - * called on the file, don't fail the below assertion (bug 2388). */ - if (file->f_flags & O_LOV_DELAY_CREATE && - ll_i2info(inode)->lli_smd == NULL) - RETURN(-EBADF); - - LASSERT(ll_i2info(inode)->lli_smd != NULL); - - down(&ll_i2info(inode)->lli_write_sem); - -repeat: - chunk = 0; /* just to fix gcc's warning */ - end = *ppos + count - 1; - - if (file->f_flags & O_APPEND) { - lock_start = 0; - lock_end = OBD_OBJECT_EOF; - } else if (sbi->ll_max_rw_chunk != 0) { - /* first, let's know the end of the current stripe */ - end = *ppos; - obd_extent_calc(sbi->ll_dt_exp, lsm, OBD_CALC_STRIPE_END, - (obd_off *)&end); - - /* correct, the end is beyond the request */ - if (end > *ppos + count - 1) - end = *ppos + count - 1; - - /* and chunk shouldn't be too large even if striping is wide */ - if (end - *ppos > sbi->ll_max_rw_chunk) - end = *ppos + sbi->ll_max_rw_chunk - 1; - lock_start = *ppos; - lock_end = end; - } else { - lock_start = *ppos; - lock_end = *ppos + count - 1; - } - node = ll_node_from_inode(inode, lock_start, lock_end, LCK_PW); - - if (IS_ERR(node)) - GOTO(out, retval = PTR_ERR(node)); - - tree.lt_fd = LUSTRE_FPRIVATE(file); - rc = ll_tree_lock(&tree, node, buf, count, - file->f_flags & O_NONBLOCK ? LDLM_FL_BLOCK_NOWAIT :0); - if (rc != 0) - GOTO(out, retval = rc); - - /* This is ok, g_f_w will overwrite this under i_sem if it races - * with a local truncate, it just makes our maxbyte checking easier. - * The i_size value gets updated in ll_extent_lock() as a consequence - * of the [0,EOF] extent lock we requested above. */ - if (file->f_flags & O_APPEND) { - *ppos = inode->i_size; - end = *ppos + count - 1; - } - - if (*ppos >= maxbytes) { - send_sig(SIGXFSZ, current, 0); - GOTO(out, retval = -EFBIG); - } - if (*ppos + count > maxbytes) - count = maxbytes - *ppos; - - /* generic_file_write handles O_APPEND after getting i_mutex */ - chunk = end - *ppos + 1; - CDEBUG(D_INFO, "Writing inode %lu, "LPSZ" bytes, offset %Lu\n", - inode->i_ino, chunk, *ppos); - retval = generic_file_write(file, buf, chunk, ppos); - ll_rw_stats_tally(ll_i2sbi(inode), current->pid, file, count, 1); - -out: - ll_tree_unlock(&tree); - - if (retval > 0) { - buf += retval; - count -= retval; - sum += retval; - if (retval == chunk && count > 0) - goto repeat; - } - - up(&ll_i2info(inode)->lli_write_sem); - - retval = (sum > 0) ? sum : retval; - ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_WRITE_BYTES, - retval > 0 ? retval : 0); - RETURN(retval); -} - -/* - * Send file content (through pagecache) somewhere with helper - */ -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) -static ssize_t ll_file_sendfile(struct file *in_file, loff_t *ppos,size_t count, - read_actor_t actor, void *target) -{ - struct inode *inode = in_file->f_dentry->d_inode; - struct ll_inode_info *lli = ll_i2info(inode); - struct lov_stripe_md *lsm = lli->lli_smd; - struct ll_lock_tree tree; - struct ll_lock_tree_node *node; - struct ost_lvb lvb; - struct ll_ra_read bead; - int rc; - ssize_t retval; - __u64 kms; - ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),size="LPSZ",offset=%Ld\n", - inode->i_ino, inode->i_generation, inode, count, *ppos); - - /* "If nbyte is 0, read() will return 0 and have no other results." - * -- Single Unix Spec */ - if (count == 0) - RETURN(0); - - ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_READ_BYTES, count); - /* turn off the kernel's read-ahead */ - in_file->f_ra.ra_pages = 0; - - /* File with no objects, nothing to lock */ - if (!lsm) - RETURN(generic_file_sendfile(in_file, ppos, count, actor, target)); - - node = ll_node_from_inode(inode, *ppos, *ppos + count - 1, LCK_PR); - tree.lt_fd = LUSTRE_FPRIVATE(in_file); - rc = ll_tree_lock(&tree, node, NULL, count, - in_file->f_flags & O_NONBLOCK?LDLM_FL_BLOCK_NOWAIT:0); - if (rc != 0) - RETURN(rc); - - ll_inode_size_lock(inode, 1); - /* - * Consistency guarantees: following possibilities exist for the - * relation between region being read and real file size at this - * moment: - * - * (A): the region is completely inside of the file; - * - * (B-x): x bytes of region are inside of the file, the rest is - * outside; - * - * (C): the region is completely outside of the file. - * - * This classification is stable under DLM lock acquired by - * ll_tree_lock() above, because to change class, other client has to - * take DLM lock conflicting with our lock. Also, any updates to - * ->i_size by other threads on this client are serialized by - * ll_inode_size_lock(). This guarantees that short reads are handled - * correctly in the face of concurrent writes and truncates. - */ - inode_init_lvb(inode, &lvb); - obd_merge_lvb(ll_i2sbi(inode)->ll_dt_exp, lsm, &lvb, 1); - kms = lvb.lvb_size; - if (*ppos + count - 1 > kms) { - /* A glimpse is necessary to determine whether we return a - * short read (B) or some zeroes at the end of the buffer (C) */ - ll_inode_size_unlock(inode, 1); - retval = ll_glimpse_size(inode, LDLM_FL_BLOCK_GRANTED); - if (retval) - goto out; - } else { - /* region is within kms and, hence, within real file size (A) */ - inode->i_size = kms; - ll_inode_size_unlock(inode, 1); - } - - CDEBUG(D_INFO, "Send ino %lu, "LPSZ" bytes, offset %lld, i_size %llu\n", - inode->i_ino, count, *ppos, inode->i_size); - - bead.lrr_start = *ppos >> CFS_PAGE_SHIFT; - bead.lrr_count = (count + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT; - ll_ra_read_in(in_file, &bead); - /* BUG: 5972 */ - file_accessed(in_file); - retval = generic_file_sendfile(in_file, ppos, count, actor, target); - ll_ra_read_ex(in_file, &bead); - - out: - ll_tree_unlock(&tree); - RETURN(retval); -} -#endif +#endif static int ll_lov_recreate_obj(struct inode *inode, struct file *file, unsigned long arg) { - struct ll_inode_info *lli = ll_i2info(inode); struct obd_export *exp = ll_i2dtexp(inode); struct ll_recreate_obj ucreatp; struct obd_trans_info oti = { 0 }; @@ -1673,20 +1199,19 @@ static int ll_lov_recreate_obj(struct inode *inode, struct file *file, struct lov_stripe_md *lsm, *lsm2; ENTRY; - if (!capable (CAP_SYS_ADMIN)) + if (!cfs_capable(CFS_CAP_SYS_ADMIN)) RETURN(-EPERM); - rc = copy_from_user(&ucreatp, (struct ll_recreate_obj *)arg, - sizeof(struct ll_recreate_obj)); - if (rc) { + if (copy_from_user(&ucreatp, (struct ll_recreate_obj *)arg, + sizeof(struct ll_recreate_obj))) RETURN(-EFAULT); - } + OBDO_ALLOC(oa); if (oa == NULL) RETURN(-ENOMEM); - down(&lli->lli_size_sem); - lsm = lli->lli_smd; + ll_inode_size_lock(inode, 0); + lsm = ll_i2info(inode)->lli_smd; if (lsm == NULL) GOTO(out, rc = -ENOENT); lsm_size = sizeof(*lsm) + (sizeof(struct lov_oinfo) * @@ -1704,14 +1229,13 @@ static int ll_lov_recreate_obj(struct inode *inode, struct file *file, obdo_from_inode(oa, inode, OBD_MD_FLTYPE | OBD_MD_FLATIME | OBD_MD_FLMTIME | OBD_MD_FLCTIME); - oti.oti_objid = NULL; memcpy(lsm2, lsm, lsm_size); rc = obd_create(exp, oa, &lsm2, &oti); OBD_FREE(lsm2, lsm_size); GOTO(out, rc); out: - up(&lli->lli_size_sem); + ll_inode_size_unlock(inode, 0); OBDO_FREE(oa); return rc; } @@ -1719,16 +1243,15 @@ out: int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file, int flags, struct lov_user_md *lum, int lum_size) { - struct ll_inode_info *lli = ll_i2info(inode); struct lov_stripe_md *lsm; struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags}; int rc = 0; ENTRY; - down(&lli->lli_size_sem); - lsm = lli->lli_smd; + ll_inode_size_lock(inode, 0); + lsm = ll_i2info(inode)->lli_smd; if (lsm) { - up(&lli->lli_size_sem); + ll_inode_size_unlock(inode, 0); CDEBUG(D_IOCTL, "stripe already exists for ino %lu\n", inode->i_ino); RETURN(-EEXIST); @@ -1746,7 +1269,7 @@ int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file, ll_release_openhandle(file->f_dentry, &oit); out: - up(&lli->lli_size_sem); + ll_inode_size_unlock(inode, 0); ll_intent_release(&oit); RETURN(rc); out_req_free: @@ -1754,8 +1277,8 @@ out_req_free: goto out; } -int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, - struct lov_mds_md **lmmp, int *lmm_size, +int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, + struct lov_mds_md **lmmp, int *lmm_size, struct ptlrpc_request **request) { struct ll_sb_info *sbi = ll_i2sbi(inode); @@ -1772,7 +1295,8 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, oc = ll_mdscapa_get(inode); rc = md_getattr_name(sbi->ll_md_exp, ll_inode2fid(inode), oc, filename, strlen(filename) + 1, - OBD_MD_FLEASIZE | OBD_MD_FLDIREA, lmmsize, &req); + OBD_MD_FLEASIZE | OBD_MD_FLDIREA, lmmsize, + ll_i2suppgid(inode), &req); capa_put(oc); if (rc < 0) { CDEBUG(D_INFO, "md_getattr_name failed " @@ -1780,10 +1304,8 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, GOTO(out, rc); } - body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); /* checked by mdc_getattr_name */ - /* swabbed by mdc_getattr_name */ - LASSERT_REPSWABBED(req, REPLY_REC_OFF); lmmsize = body->eadatasize; @@ -1792,73 +1314,37 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, GOTO(out, rc = -ENODATA); } - lmm = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, lmmsize); + lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize); LASSERT(lmm != NULL); - LASSERT_REPSWABBED(req, REPLY_REC_OFF + 1); + + if ((lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1)) && + (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3))) { + GOTO(out, rc = -EPROTO); + } /* * This is coming from the MDS, so is probably in * little endian. We convert it to host endian before * passing it to userspace. */ - if (lmm->lmm_magic == __swab32(LOV_MAGIC)) { - lustre_swab_lov_user_md((struct lov_user_md *)lmm); - lustre_swab_lov_user_md_objects((struct lov_user_md *)lmm); - } else if (lmm->lmm_magic == __swab32(LOV_MAGIC_JOIN)) { - lustre_swab_lov_user_md_join((struct lov_user_md_join *)lmm); - } - - if (lmm->lmm_magic == LOV_MAGIC_JOIN) { - struct lov_stripe_md *lsm; - struct lov_user_md_join *lmj; - int lmj_size, i, aindex = 0; - - rc = obd_unpackmd(sbi->ll_dt_exp, &lsm, lmm, lmmsize); - if (rc < 0) - GOTO(out, rc = -ENOMEM); - rc = obd_checkmd(sbi->ll_dt_exp, sbi->ll_md_exp, lsm); - if (rc) - GOTO(out_free_memmd, rc); - - lmj_size = sizeof(struct lov_user_md_join) + - lsm->lsm_stripe_count * - sizeof(struct lov_user_ost_data_join); - OBD_ALLOC(lmj, lmj_size); - if (!lmj) - GOTO(out_free_memmd, rc = -ENOMEM); - - memcpy(lmj, lmm, sizeof(struct lov_user_md_join)); - for (i = 0; i < lsm->lsm_stripe_count; i++) { - struct lov_extent *lex = - &lsm->lsm_array->lai_ext_array[aindex]; - - if (lex->le_loi_idx + lex->le_stripe_count <= i) - aindex ++; - CDEBUG(D_INFO, "aindex %d i %d l_extent_start " - LPU64" len %d\n", aindex, i, - lex->le_start, (int)lex->le_len); - lmj->lmm_objects[i].l_extent_start = - lex->le_start; - - if ((int)lex->le_len == -1) - lmj->lmm_objects[i].l_extent_end = -1; - else - lmj->lmm_objects[i].l_extent_end = - lex->le_start + lex->le_len; - lmj->lmm_objects[i].l_object_id = - lsm->lsm_oinfo[i]->loi_id; - lmj->lmm_objects[i].l_object_gr = - lsm->lsm_oinfo[i]->loi_gr; - lmj->lmm_objects[i].l_ost_gen = - lsm->lsm_oinfo[i]->loi_ost_gen; - lmj->lmm_objects[i].l_ost_idx = - lsm->lsm_oinfo[i]->loi_ost_idx; + if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) { + /* if function called for directory - we should + * avoid swab not existent lsm objects */ + if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) { + lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lmm); + if (S_ISREG(body->mode)) + lustre_swab_lov_user_md_objects( + ((struct lov_user_md_v1 *)lmm)->lmm_objects, + ((struct lov_user_md_v1 *)lmm)->lmm_stripe_count); + } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) { + lustre_swab_lov_user_md_v3((struct lov_user_md_v3 *)lmm); + if (S_ISREG(body->mode)) + lustre_swab_lov_user_md_objects( + ((struct lov_user_md_v3 *)lmm)->lmm_objects, + ((struct lov_user_md_v3 *)lmm)->lmm_stripe_count); } - lmm = (struct lov_mds_md *)lmj; - lmmsize = lmj_size; -out_free_memmd: - obd_free_memmd(sbi->ll_dt_exp, &lsm); } + out: *lmmp = lmm; *lmm_size = lmmsize; @@ -1876,15 +1362,14 @@ static int ll_lov_setea(struct inode *inode, struct file *file, int rc; ENTRY; - if (!capable (CAP_SYS_ADMIN)) + if (!cfs_capable(CFS_CAP_SYS_ADMIN)) RETURN(-EPERM); OBD_ALLOC(lump, lum_size); if (lump == NULL) { RETURN(-ENOMEM); } - rc = copy_from_user(lump, (struct lov_user_md *)arg, lum_size); - if (rc) { + if (copy_from_user(lump, (struct lov_user_md *)arg, lum_size)) { OBD_FREE(lump, lum_size); RETURN(-EFAULT); } @@ -1898,23 +1383,32 @@ static int ll_lov_setea(struct inode *inode, struct file *file, static int ll_lov_setstripe(struct inode *inode, struct file *file, unsigned long arg) { - struct lov_user_md lum, *lump = (struct lov_user_md *)arg; + struct lov_user_md_v3 lumv3; + struct lov_user_md_v1 *lumv1 = (struct lov_user_md_v1 *)&lumv3; + 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 lum_size; int rc; int flags = FMODE_WRITE; ENTRY; - /* Bug 1152: copy properly when this is no longer true */ - LASSERT(sizeof(lum) == sizeof(*lump)); - LASSERT(sizeof(lum.lmm_objects[0]) == sizeof(lump->lmm_objects[0])); - rc = copy_from_user(&lum, lump, sizeof(lum)); - if (rc) + /* first try with v1 which is smaller than v3 */ + lum_size = sizeof(struct lov_user_md_v1); + if (copy_from_user(lumv1, lumv1p, lum_size)) RETURN(-EFAULT); - rc = ll_lov_setstripe_ea_info(inode, file, flags, &lum, sizeof(lum)); + if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) { + lum_size = sizeof(struct lov_user_md_v3); + if (copy_from_user(&lumv3, lumv3p, lum_size)) + RETURN(-EFAULT); + } + + rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size); if (rc == 0) { - put_user(0, &lump->lmm_stripe_count); + put_user(0, &lumv1p->lmm_stripe_count); rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), - 0, ll_i2info(inode)->lli_smd, lump); + 0, ll_i2info(inode)->lli_smd, + (void *)arg); } RETURN(rc); } @@ -1930,233 +1424,89 @@ static int ll_lov_getstripe(struct inode *inode, unsigned long arg) (void *)arg); } -static int ll_get_grouplock(struct inode *inode, struct file *file, - unsigned long arg) +int ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg) { - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); - ldlm_policy_data_t policy = { .l_extent = { .start = 0, - .end = OBD_OBJECT_EOF}}; - struct lustre_handle lockh = { 0 }; - struct ll_inode_info *lli = ll_i2info(inode); - struct lov_stripe_md *lsm = lli->lli_smd; - int flags = 0, rc; + struct ll_inode_info *lli = ll_i2info(inode); + struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ccc_grouplock grouplock; + int rc; ENTRY; + if (ll_file_nolock(file)) + RETURN(-EOPNOTSUPP); + + spin_lock(&lli->lli_lock); if (fd->fd_flags & LL_FILE_GROUP_LOCKED) { + CWARN("group lock already existed with gid %lu\n", + fd->fd_grouplock.cg_gid); + spin_unlock(&lli->lli_lock); RETURN(-EINVAL); } + LASSERT(fd->fd_grouplock.cg_lock == NULL); + spin_unlock(&lli->lli_lock); - policy.l_extent.gid = arg; - if (file->f_flags & O_NONBLOCK) - flags = LDLM_FL_BLOCK_NOWAIT; - - rc = ll_extent_lock(fd, inode, lsm, LCK_GROUP, &policy, &lockh, flags); + rc = cl_get_grouplock(cl_i2info(inode)->lli_clob, + arg, (file->f_flags & O_NONBLOCK), &grouplock); if (rc) RETURN(rc); - fd->fd_flags |= LL_FILE_GROUP_LOCKED|LL_FILE_IGNORE_LOCK; - fd->fd_gid = arg; - memcpy(&fd->fd_cwlockh, &lockh, sizeof(lockh)); - - RETURN(0); -} - -static int ll_put_grouplock(struct inode *inode, struct file *file, - unsigned long arg) -{ - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); - struct ll_inode_info *lli = ll_i2info(inode); - struct lov_stripe_md *lsm = lli->lli_smd; - int rc; - ENTRY; - - if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) { - /* Ugh, it's already unlocked. */ + spin_lock(&lli->lli_lock); + if (fd->fd_flags & LL_FILE_GROUP_LOCKED) { + spin_unlock(&lli->lli_lock); + CERROR("another thread just won the race\n"); + cl_put_grouplock(&grouplock); RETURN(-EINVAL); } - if (fd->fd_gid != arg) /* Ugh? Unlocking with different gid? */ - RETURN(-EINVAL); - - fd->fd_flags &= ~(LL_FILE_GROUP_LOCKED|LL_FILE_IGNORE_LOCK); - - rc = ll_extent_unlock(fd, inode, lsm, LCK_GROUP, &fd->fd_cwlockh); - if (rc) - RETURN(rc); - - fd->fd_gid = 0; - memset(&fd->fd_cwlockh, 0, sizeof(fd->fd_cwlockh)); + fd->fd_flags |= LL_FILE_GROUP_LOCKED; + fd->fd_grouplock = grouplock; + spin_unlock(&lli->lli_lock); + CDEBUG(D_INFO, "group lock %lu obtained\n", arg); RETURN(0); } -static int join_sanity_check(struct inode *head, struct inode *tail) +int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg) { + struct ll_inode_info *lli = ll_i2info(inode); + struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ccc_grouplock grouplock; ENTRY; - if ((ll_i2sbi(head)->ll_flags & LL_SBI_JOIN) == 0) { - CERROR("server do not support join \n"); - RETURN(-EINVAL); - } - if (!S_ISREG(tail->i_mode) || !S_ISREG(head->i_mode)) { - CERROR("tail ino %lu and ino head %lu must be regular\n", - head->i_ino, tail->i_ino); - RETURN(-EINVAL); - } - if (head->i_ino == tail->i_ino) { - CERROR("file %lu can not be joined to itself \n", head->i_ino); - RETURN(-EINVAL); - } - if (head->i_size % JOIN_FILE_ALIGN) { - CERROR("hsize %llu must be times of 64K\n", head->i_size); - RETURN(-EINVAL); - } - RETURN(0); -} - -static int join_file(struct inode *head_inode, struct file *head_filp, - struct file *tail_filp) -{ - struct inode *tail_inode, *tail_parent; - struct dentry *tail_dentry = tail_filp->f_dentry; - struct lookup_intent oit = {.it_op = IT_OPEN, - .it_flags = head_filp->f_flags|O_JOIN_FILE}; - struct lustre_handle lockh; - struct md_op_data *op_data; - int rc; - ENTRY; - - tail_dentry = tail_filp->f_dentry; - tail_inode = tail_dentry->d_inode; - tail_parent = tail_dentry->d_parent->d_inode; - - op_data = ll_prep_md_op_data(NULL, head_inode, tail_parent, - tail_dentry->d_name.name, - tail_dentry->d_name.len, 0, - LUSTRE_OPC_ANY, &head_inode->i_size); - if (IS_ERR(op_data)) - RETURN(PTR_ERR(op_data)); - rc = md_enqueue(ll_i2mdexp(head_inode), LDLM_IBITS, &oit, LCK_CW, - op_data, &lockh, NULL, 0, ldlm_completion_ast, - ll_md_blocking_ast, NULL, 0); - - ll_finish_md_op_data(op_data); - if (rc < 0) - GOTO(out, rc); - - rc = oit.d.lustre.it_status; - - if (rc < 0 || it_open_error(DISP_OPEN_OPEN, &oit)) { - rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, &oit); - ptlrpc_req_finished((struct ptlrpc_request *) - oit.d.lustre.it_data); - GOTO(out, rc); + spin_lock(&lli->lli_lock); + if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) { + spin_unlock(&lli->lli_lock); + CWARN("no group lock held\n"); + RETURN(-EINVAL); } + LASSERT(fd->fd_grouplock.cg_lock != NULL); - if (oit.d.lustre.it_lock_mode) { /* If we got lock - release it right - * away */ - ldlm_lock_decref(&lockh, oit.d.lustre.it_lock_mode); - oit.d.lustre.it_lock_mode = 0; + if (fd->fd_grouplock.cg_gid != arg) { + CWARN("group lock %lu doesn't match current id %lu\n", + arg, fd->fd_grouplock.cg_gid); + spin_unlock(&lli->lli_lock); + RETURN(-EINVAL); } - ll_release_openhandle(head_filp->f_dentry, &oit); -out: - ll_intent_release(&oit); - RETURN(rc); -} - -static int ll_file_join(struct inode *head, struct file *filp, - char *filename_tail) -{ - struct inode *tail = NULL, *first = NULL, *second = NULL; - struct dentry *tail_dentry; - struct file *tail_filp, *first_filp, *second_filp; - struct ll_lock_tree first_tree, second_tree; - struct ll_lock_tree_node *first_node, *second_node; - struct ll_inode_info *hlli = ll_i2info(head), *tlli; - int rc = 0, cleanup_phase = 0; - ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:head=%lu/%u(%p) tail %s\n", - head->i_ino, head->i_generation, head, filename_tail); - - tail_filp = filp_open(filename_tail, O_WRONLY, 0644); - if (IS_ERR(tail_filp)) { - CERROR("Can not open tail file %s", filename_tail); - rc = PTR_ERR(tail_filp); - GOTO(cleanup, rc); - } - tail = igrab(tail_filp->f_dentry->d_inode); - - tlli = ll_i2info(tail); - tail_dentry = tail_filp->f_dentry; - LASSERT(tail_dentry); - cleanup_phase = 1; - - /*reorder the inode for lock sequence*/ - first = head->i_ino > tail->i_ino ? head : tail; - second = head->i_ino > tail->i_ino ? tail : head; - first_filp = head->i_ino > tail->i_ino ? filp : tail_filp; - second_filp = head->i_ino > tail->i_ino ? tail_filp : filp; - - CDEBUG(D_INFO, "reorder object from %lu:%lu to %lu:%lu \n", - head->i_ino, tail->i_ino, first->i_ino, second->i_ino); - first_node = ll_node_from_inode(first, 0, OBD_OBJECT_EOF, LCK_EX); - if (IS_ERR(first_node)){ - rc = PTR_ERR(first_node); - GOTO(cleanup, rc); - } - first_tree.lt_fd = first_filp->private_data; - rc = ll_tree_lock(&first_tree, first_node, NULL, 0, 0); - if (rc != 0) - GOTO(cleanup, rc); - cleanup_phase = 2; - - second_node = ll_node_from_inode(second, 0, OBD_OBJECT_EOF, LCK_EX); - if (IS_ERR(second_node)){ - rc = PTR_ERR(second_node); - GOTO(cleanup, rc); - } - second_tree.lt_fd = second_filp->private_data; - rc = ll_tree_lock(&second_tree, second_node, NULL, 0, 0); - if (rc != 0) - GOTO(cleanup, rc); - cleanup_phase = 3; - - rc = join_sanity_check(head, tail); - if (rc) - GOTO(cleanup, rc); + grouplock = fd->fd_grouplock; + memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock)); + fd->fd_flags &= ~LL_FILE_GROUP_LOCKED; + spin_unlock(&lli->lli_lock); - rc = join_file(head, filp, tail_filp); - if (rc) - GOTO(cleanup, rc); -cleanup: - switch (cleanup_phase) { - case 3: - ll_tree_unlock(&second_tree); - obd_cancel_unused(ll_i2dtexp(second), - ll_i2info(second)->lli_smd, 0, NULL); - case 2: - ll_tree_unlock(&first_tree); - obd_cancel_unused(ll_i2dtexp(first), - ll_i2info(first)->lli_smd, 0, NULL); - case 1: - filp_close(tail_filp, 0); - if (tail) - iput(tail); - if (head && rc == 0) { - obd_free_memmd(ll_i2sbi(head)->ll_dt_exp, - &hlli->lli_smd); - hlli->lli_smd = NULL; - } - case 0: - break; - default: - CERROR("invalid cleanup_phase %d\n", cleanup_phase); - LBUG(); - } - RETURN(rc); + cl_put_grouplock(&grouplock); + CDEBUG(D_INFO, "group lock %lu released\n", arg); + RETURN(0); } +/** + * Close inode open handle + * + * \param dentry [in] dentry which contains the inode + * \param it [in,out] intent which contains open info and result + * + * \retval 0 success + * \retval <0 failure + */ int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it) { struct inode *inode = dentry->d_inode; @@ -2187,11 +1537,91 @@ int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it) inode, och); out: /* this one is in place of ll_file_open */ - ptlrpc_req_finished(it->d.lustre.it_data); + if (it_disposition(it, DISP_ENQ_OPEN_REF)) + ptlrpc_req_finished(it->d.lustre.it_data); it_clear_disposition(it, DISP_ENQ_OPEN_REF); RETURN(rc); } +/** + * Get size for inode for which FIEMAP mapping is requested. + * Make the FIEMAP get_info call and returns the result. + */ +int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap, + int num_bytes) +{ + struct obd_export *exp = ll_i2dtexp(inode); + struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd; + struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, }; + int vallen = num_bytes; + int rc; + ENTRY; + + /* If the stripe_count > 1 and the application does not understand + * DEVICE_ORDER flag, then it cannot interpret the extents correctly. + */ + if (lsm->lsm_stripe_count > 1 && + !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER)) + return -EOPNOTSUPP; + + fm_key.oa.o_id = lsm->lsm_object_id; + fm_key.oa.o_gr = lsm->lsm_object_gr; + fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP; + + obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLFID | OBD_MD_FLGROUP | + OBD_MD_FLSIZE); + + /* If filesize is 0, then there would be no objects for mapping */ + if (fm_key.oa.o_size == 0) { + fiemap->fm_mapped_extents = 0; + RETURN(0); + } + + memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap)); + + rc = obd_get_info(exp, sizeof(fm_key), &fm_key, &vallen, fiemap, lsm); + if (rc) + CERROR("obd_get_info failed: rc = %d\n", rc); + + RETURN(rc); +} + +int ll_fid2path(struct obd_export *exp, void *arg) +{ + struct getinfo_fid2path *gfout, *gfin; + int outsize, rc; + ENTRY; + + /* Need to get the buflen */ + OBD_ALLOC_PTR(gfin); + if (gfin == NULL) + RETURN(-ENOMEM); + if (copy_from_user(gfin, arg, sizeof(*gfin))) { + OBD_FREE_PTR(gfin); + RETURN(-EFAULT); + } + + outsize = sizeof(*gfout) + gfin->gf_pathlen; + OBD_ALLOC(gfout, outsize); + if (gfout == NULL) { + OBD_FREE_PTR(gfin); + RETURN(-ENOMEM); + } + memcpy(gfout, gfin, sizeof(*gfout)); + OBD_FREE_PTR(gfin); + + /* Call mdc_iocontrol */ + rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL); + if (rc) + GOTO(gf_free, rc); + if (copy_to_user(arg, gfout, outsize)) + rc = -EFAULT; + +gf_free: + OBD_FREE(gfout, outsize); + RETURN(rc); +} + int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { @@ -2241,23 +1671,78 @@ int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd, RETURN(ll_lov_getstripe(inode, arg)); case LL_IOC_RECREATE_OBJ: RETURN(ll_lov_recreate_obj(inode, file, arg)); - case EXT3_IOC_GETFLAGS: - case EXT3_IOC_SETFLAGS: - RETURN(ll_iocontrol(inode, file, cmd, arg)); - case EXT3_IOC_GETVERSION_OLD: - case EXT3_IOC_GETVERSION: - RETURN(put_user(inode->i_generation, (int *)arg)); - case LL_IOC_JOIN: { - char *ftail; - int rc; + case FSFILT_IOC_FIEMAP: { + struct ll_user_fiemap *fiemap_s; + size_t num_bytes, ret_bytes; + unsigned int extent_count; + int rc = 0; + + /* Get the extent count so we can calculate the size of + * required fiemap buffer */ + if (get_user(extent_count, + &((struct ll_user_fiemap __user *)arg)->fm_extent_count)) + RETURN(-EFAULT); + num_bytes = sizeof(*fiemap_s) + (extent_count * + sizeof(struct ll_fiemap_extent)); + OBD_VMALLOC(fiemap_s, num_bytes); + if (fiemap_s == NULL) + RETURN(-ENOMEM); + + if (copy_from_user(fiemap_s,(struct ll_user_fiemap __user *)arg, + sizeof(*fiemap_s))) + GOTO(error, rc = -EFAULT); + + if (fiemap_s->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) { + fiemap_s->fm_flags = fiemap_s->fm_flags & + ~LUSTRE_FIEMAP_FLAGS_COMPAT; + if (copy_to_user((char *)arg, fiemap_s, + sizeof(*fiemap_s))) + GOTO(error, rc = -EFAULT); + + GOTO(error, rc = -EBADR); + } + + /* If fm_extent_count is non-zero, read the first extent since + * it is used to calculate end_offset and device from previous + * fiemap call. */ + if (extent_count) { + if (copy_from_user(&fiemap_s->fm_extents[0], + (char __user *)arg + sizeof(*fiemap_s), + sizeof(struct ll_fiemap_extent))) + GOTO(error, rc = -EFAULT); + } + + if (fiemap_s->fm_flags & FIEMAP_FLAG_SYNC) { + int rc; - ftail = getname((const char *)arg); - if (IS_ERR(ftail)) - RETURN(PTR_ERR(ftail)); - rc = ll_file_join(inode, file, ftail); - putname(ftail); + rc = filemap_fdatawrite(inode->i_mapping); + if (rc) + GOTO(error, rc); + } + + rc = ll_do_fiemap(inode, fiemap_s, num_bytes); + if (rc) + GOTO(error, rc); + + ret_bytes = sizeof(struct ll_user_fiemap); + + if (extent_count != 0) + ret_bytes += (fiemap_s->fm_mapped_extents * + sizeof(struct ll_fiemap_extent)); + + if (copy_to_user((void *)arg, fiemap_s, ret_bytes)) + rc = -EFAULT; + +error: + OBD_VFREE(fiemap_s, num_bytes); RETURN(rc); } + case FSFILT_IOC_GETFLAGS: + case FSFILT_IOC_SETFLAGS: + RETURN(ll_iocontrol(inode, file, cmd, arg)); + case FSFILT_IOC_GETVERSION_OLD: + case FSFILT_IOC_GETVERSION: + RETURN(put_user(inode->i_generation, (int *)arg)); case LL_IOC_GROUP_LOCK: RETURN(ll_get_grouplock(inode, file, arg)); case LL_IOC_GROUP_UNLOCK: @@ -2268,61 +1753,58 @@ int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd, /* 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_FLUSHCTX: RETURN(ll_flush_ctx(inode)); - case LL_IOC_GETFACL: { - struct rmtacl_ioctl_data ioc; - - if (copy_from_user(&ioc, (void *)arg, sizeof(ioc))) + case LL_IOC_PATH2FID: { + if (copy_to_user((void *)arg, ll_inode2fid(inode), + sizeof(struct lu_fid))) RETURN(-EFAULT); - RETURN(ll_ioctl_getfacl(inode, &ioc)); + RETURN(0); } - case LL_IOC_SETFACL: { - struct rmtacl_ioctl_data ioc; + case OBD_IOC_FID2PATH: + RETURN(ll_fid2path(ll_i2mdexp(inode), (void *)arg)); - if (copy_from_user(&ioc, (void *)arg, sizeof(ioc))) - RETURN(-EFAULT); + default: { + int err; + + if (LLIOC_STOP == + ll_iocontrol_call(inode, file, cmd, arg, &err)) + RETURN(err); - RETURN(ll_ioctl_setfacl(inode, &ioc)); - } - default: RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL, (void *)arg)); } + } } loff_t ll_file_seek(struct file *file, loff_t offset, int origin) { struct inode *inode = file->f_dentry->d_inode; - struct ll_inode_info *lli = ll_i2info(inode); - struct lov_stripe_md *lsm = lli->lli_smd; loff_t retval; ENTRY; - retval = offset + ((origin == 2) ? inode->i_size : + 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", 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; - if (lsm != NULL) { - rc = ll_glimpse_size(inode, nonblock); - if (rc != 0) - RETURN(rc); - } + rc = cl_glimpse_size(inode); + if (rc != 0) + RETURN(rc); ll_inode_size_lock(inode, 0); - offset += inode->i_size; + offset += i_size_read(inode); ll_inode_size_unlock(inode, 0); } else if (origin == 1) { /* SEEK_CUR */ offset += file->f_pos; @@ -2332,14 +1814,10 @@ loff_t ll_file_seek(struct file *file, loff_t offset, int origin) if (offset >= 0 && offset <= ll_file_maxbytes(inode)) { if (offset != file->f_pos) { file->f_pos = offset; -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) - file->f_reada = 0; - file->f_version = ++event; -#endif } retval = offset; } - + RETURN(retval); } @@ -2383,7 +1861,7 @@ int ll_fsync(struct file *file, struct dentry *dentry, int data) if (data && lsm) { struct obdo *oa; - + OBDO_ALLOC(oa); if (!oa) RETURN(rc ? rc : -ENOMEM); @@ -2395,7 +1873,7 @@ int ll_fsync(struct file *file, struct dentry *dentry, int data) OBD_MD_FLMTIME | OBD_MD_FLCTIME | OBD_MD_FLGROUP); - oc = ll_osscapa_get(inode, 0, CAPA_OPC_OSS_WRITE); + 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); @@ -2411,14 +1889,12 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) { struct inode *inode = file->f_dentry->d_inode; struct ll_sb_info *sbi = ll_i2sbi(inode); - struct ldlm_res_id res_id = - { .name = { fid_seq(ll_inode2fid(inode)), - fid_oid(ll_inode2fid(inode)), - fid_ver(ll_inode2fid(inode)), - LDLM_FLOCK} }; + struct ldlm_enqueue_info einfo = { .ei_type = LDLM_FLOCK, + .ei_cb_cp =ldlm_flock_completion_ast, + .ei_cbdata = file_lock }; + struct md_op_data *op_data; struct lustre_handle lockh = {0}; ldlm_policy_data_t flock; - ldlm_mode_t mode = 0; int flags = 0; int rc; ENTRY; @@ -2427,7 +1903,7 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) inode->i_ino, file_lock); ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1); - + if (file_lock->fl_flags & FL_FLOCK) { LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK)); /* set missing params for flock() calls */ @@ -2440,7 +1916,7 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) switch (file_lock->fl_type) { case F_RDLCK: - mode = LCK_PR; + einfo.ei_mode = LCK_PR; break; case F_UNLCK: /* An unlock request may or may not have any relation to @@ -2451,14 +1927,14 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) * information that is given with a normal read or write record * lock request. To avoid creating another ldlm unlock (cancel) * message we'll treat a LCK_NL flock request as an unlock. */ - mode = LCK_NL; + einfo.ei_mode = LCK_NL; break; case F_WRLCK: - mode = LCK_PW; + einfo.ei_mode = LCK_PW; break; default: CERROR("unknown fcntl lock type: %d\n", file_lock->fl_type); - LBUG(); + RETURN (-EINVAL); } switch (cmd) { @@ -2481,25 +1957,33 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) flags = LDLM_FL_TEST_LOCK; /* Save the old mode so that if the mode in the lock changes we * can decrement the appropriate reader or writer refcount. */ - file_lock->fl_type = mode; + file_lock->fl_type = einfo.ei_mode; break; default: CERROR("unknown fcntl lock command: %d\n", cmd); - LBUG(); + RETURN (-EINVAL); } + 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)); + CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags=%#x, mode=%u, " "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid, - flags, mode, flock.l_flock.start, flock.l_flock.end); + flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end); + + rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL, + op_data, &lockh, &flock, 0, NULL /* req */, flags); - rc = ldlm_cli_enqueue(sbi->ll_md_exp, NULL, &res_id, - LDLM_FLOCK, &flock, mode, &flags, NULL, - ldlm_flock_completion_ast, NULL, file_lock, - NULL, 0, NULL, &lockh, 0); - if ((file_lock->fl_flags & FL_FLOCK) && (rc == 0)) + ll_finish_md_op_data(op_data); + + 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 - if ((file_lock->fl_flags & FL_POSIX) && (rc == 0) && + 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 @@ -2530,13 +2014,30 @@ int ll_have_md_lock(struct inode *inode, __u64 bits) 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, &lockh)) { + LCK_CR|LCK_CW|LCK_PR|LCK_PW, &lockh)) { RETURN(1); } - RETURN(0); } +ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits, + struct lustre_handle *lockh) +{ + ldlm_policy_data_t policy = { .l_inodebits = {bits}}; + struct lu_fid *fid; + ldlm_mode_t rc; + int flags; + ENTRY; + + fid = &ll_i2info(inode)->lli_fid; + CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid)); + + flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING; + rc = md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy, + LCK_CR|LCK_CW|LCK_PR|LCK_PW, lockh); + RETURN(rc); +} + static int ll_inode_revalidate_fini(struct inode *inode, int rc) { if (rc == -ENOENT) { /* Already unlinked. Just update nlink * and return success */ @@ -2558,13 +2059,14 @@ static int ll_inode_revalidate_fini(struct inode *inode, int rc) { return 0; } -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; struct ptlrpc_request *req = NULL; struct ll_sb_info *sbi; struct obd_export *exp; - int rc; + int rc = 0; ENTRY; if (!inode) { @@ -2575,9 +2077,6 @@ int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it) CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n", inode->i_ino, inode->i_generation, inode, dentry->d_name.name); -#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)) - ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_REVALIDATE, 1); -#endif exp = ll_i2mdexp(inode); @@ -2592,20 +2091,20 @@ int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it) if (IS_ERR(op_data)) RETURN(PTR_ERR(op_data)); - oit.it_flags |= O_CHECK_STALE; + oit.it_create_mode |= M_CHECK_STALE; rc = md_intent_lock(exp, op_data, NULL, 0, /* we are not interested in name based lookup */ &oit, 0, &req, ll_md_blocking_ast, 0); ll_finish_md_op_data(op_data); - oit.it_flags &= ~O_CHECK_STALE; + oit.it_create_mode &= ~M_CHECK_STALE; if (rc < 0) { rc = ll_inode_revalidate_fini(inode, rc); GOTO (out, rc); } - rc = ll_revalidate_it_finish(req, DLM_REPLY_REC_OFF, &oit, dentry); + rc = ll_revalidate_it_finish(req, &oit, dentry); if (rc != 0) { ll_intent_release(&oit); GOTO(out, rc); @@ -2621,9 +2120,9 @@ int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it) spin_unlock(&dcache_lock); } - ll_lookup_finish_locks(&oit, dentry); - } else if (!ll_have_md_lock(dentry->d_inode, - MDS_INODELOCK_UPDATE)) { + ll_finish_locks(&oit, dentry); + } else if (!ll_have_md_lock(dentry->d_inode, ibits)) { + struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode); obd_valid valid = OBD_MD_FLGETATTR; struct obd_capa *oc; @@ -2647,26 +2146,34 @@ int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it) RETURN(rc); } - rc = ll_prep_inode(&inode, req, REPLY_REC_OFF, - NULL); - if (rc) - GOTO(out, rc); + rc = ll_prep_inode(&inode, req, NULL); } +out: + ptlrpc_req_finished(req); + return rc; +} + +int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it) +{ + int rc; + ENTRY; + + rc = __ll_inode_revalidate_it(dentry, it, MDS_INODELOCK_UPDATE | + MDS_INODELOCK_LOOKUP); /* if object not yet allocated, don't validate size */ - if (ll_i2info(inode)->lli_smd == NULL) - GOTO(out, rc = 0); + if (rc == 0 && ll_i2info(dentry->d_inode)->lli_smd == NULL) + RETURN(0); - /* ll_glimpse_size will prefer locally cached writes if they extend + /* cl_glimpse_size will prefer locally cached writes if they extend * the file */ - rc = ll_glimpse_size(inode, 0); - EXIT; -out: - ptlrpc_req_finished(req); - return rc; + + if (rc == 0) + rc = cl_glimpse_size(dentry->d_inode); + + RETURN(rc); } -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) int ll_getattr_it(struct vfsmount *mnt, struct dentry *de, struct lookup_intent *it, struct kstat *stat) { @@ -2696,7 +2203,7 @@ int ll_getattr_it(struct vfsmount *mnt, struct dentry *de, #endif ll_inode_size_lock(inode, 0); - stat->size = inode->i_size; + stat->size = i_size_read(inode); stat->blocks = inode->i_blocks; ll_inode_size_unlock(inode, 0); @@ -2708,8 +2215,27 @@ int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat) return ll_getattr_it(mnt, de, &it, stat); } + +#ifdef HAVE_LINUX_FIEMAP_H +int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, + __u64 start, __u64 len) +{ + int rc; + struct ll_user_fiemap *fiemap = (struct ll_user_fiemap*)( + fieinfo->fi_extents_start - sizeof(ll_user_fiemap)); + + rc = ll_do_fiemap(inode, fiemap, sizeof(*fiemap) + + fiemap->fm_extent_count * + sizeof(struct ll_fiemap_extent)); + + fieinfo->fi_flags = fiemap->fm_flags; + fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents; + + return rc; +} #endif + static int lustre_check_acl(struct inode *inode, int mask) { @@ -2736,22 +2262,40 @@ int lustre_check_acl(struct inode *inode, int mask) } #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) +#else +int ll_inode_permission(struct inode *inode, int mask) +#endif { - CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), mask %o\n", - inode->i_ino, inode->i_generation, inode, mask); + int rc = 0; + ENTRY; + + /* as root inode are NOT getting validated in lookup operation, + * need to do it before permission check. */ + + if (inode == inode->i_sb->s_root->d_inode) { + struct lookup_intent it = { .it_op = IT_LOOKUP }; + + rc = __ll_inode_revalidate_it(inode->i_sb->s_root, &it, + MDS_INODELOCK_LOOKUP); + if (rc) + RETURN(rc); + } + + CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n", + inode->i_ino, inode->i_generation, inode, inode->i_mode, 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); - return generic_permission(inode, mask, lustre_check_acl); + rc = generic_permission(inode, mask, lustre_check_acl); + + RETURN(rc); } #else -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)) int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd) -#else -int ll_inode_permission(struct inode *inode, int mask) -#endif { int mode = inode->i_mode; int rc; @@ -2791,43 +2335,65 @@ check_groups: check_capabilities: if (!(mask & MAY_EXEC) || (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode)) - if (capable(CAP_DAC_OVERRIDE)) + if (cfs_capable(CFS_CAP_DAC_OVERRIDE)) return 0; - if (capable(CAP_DAC_READ_SEARCH) && ((mask == MAY_READ) || + 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 +#define READ_FUNCTION ll_file_readv +#define WRITE_METHOD writev +#define WRITE_FUNCTION ll_file_writev +#else +#define READ_METHOD aio_read +#define READ_FUNCTION ll_file_aio_read +#define WRITE_METHOD aio_write +#define WRITE_FUNCTION ll_file_aio_write +#endif + /* -o localflock - only provides locally consistent flock locks */ struct file_operations ll_file_operations = { .read = ll_file_read, + .READ_METHOD = READ_FUNCTION, .write = ll_file_write, + .WRITE_METHOD = WRITE_FUNCTION, .ioctl = ll_file_ioctl, .open = ll_file_open, .release = ll_file_release, .mmap = ll_file_mmap, .llseek = ll_file_seek, -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) +#ifdef HAVE_KERNEL_SENDFILE .sendfile = ll_file_sendfile, #endif +#ifdef HAVE_KERNEL_SPLICE_READ + .splice_read = ll_file_splice_read, +#endif .fsync = ll_fsync, }; struct file_operations ll_file_operations_flock = { .read = ll_file_read, + .READ_METHOD = READ_FUNCTION, .write = ll_file_write, + .WRITE_METHOD = WRITE_FUNCTION, .ioctl = ll_file_ioctl, .open = ll_file_open, .release = ll_file_release, .mmap = ll_file_mmap, .llseek = ll_file_seek, -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) +#ifdef HAVE_KERNEL_SENDFILE .sendfile = ll_file_sendfile, #endif +#ifdef HAVE_KERNEL_SPLICE_READ + .splice_read = ll_file_splice_read, +#endif .fsync = ll_fsync, #ifdef HAVE_F_OP_FLOCK .flock = ll_file_flock, @@ -2838,15 +2404,20 @@ struct file_operations ll_file_operations_flock = { /* These are for -o noflock - to return ENOSYS on flock calls */ struct file_operations ll_file_operations_noflock = { .read = ll_file_read, + .READ_METHOD = READ_FUNCTION, .write = ll_file_write, + .WRITE_METHOD = WRITE_FUNCTION, .ioctl = ll_file_ioctl, .open = ll_file_open, .release = ll_file_release, .mmap = ll_file_mmap, .llseek = ll_file_seek, -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) +#ifdef HAVE_KERNEL_SENDFILE .sendfile = ll_file_sendfile, #endif +#ifdef HAVE_KERNEL_SPLICE_READ + .splice_read = ll_file_splice_read, +#endif .fsync = ll_fsync, #ifdef HAVE_F_OP_FLOCK .flock = ll_file_noflock, @@ -2855,20 +2426,118 @@ struct file_operations ll_file_operations_noflock = { }; struct inode_operations ll_file_inode_operations = { -#ifdef LUSTRE_KERNEL_VERSION +#ifdef HAVE_VFS_INTENT_PATCHES .setattr_raw = ll_setattr_raw, #endif .setattr = ll_setattr, .truncate = ll_truncate, -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) .getattr = ll_getattr, -#else - .revalidate_it = ll_inode_revalidate_it, -#endif .permission = ll_inode_permission, .setxattr = ll_setxattr, .getxattr = ll_getxattr, .listxattr = ll_listxattr, .removexattr = ll_removexattr, +#ifdef HAVE_LINUX_FIEMAP_H + .fiemap = ll_fiemap, +#endif +}; + +/* dynamic ioctl number support routins */ +static struct llioc_ctl_data { + struct rw_semaphore ioc_sem; + struct list_head ioc_head; +} llioc = { + __RWSEM_INITIALIZER(llioc.ioc_sem), + CFS_LIST_HEAD_INIT(llioc.ioc_head) +}; + + +struct llioc_data { + struct list_head iocd_list; + unsigned int iocd_size; + llioc_callback_t iocd_cb; + unsigned int iocd_count; + unsigned int iocd_cmd[0]; }; +void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd) +{ + unsigned int size; + struct llioc_data *in_data = NULL; + ENTRY; + + if (cb == NULL || cmd == NULL || + count > LLIOC_MAX_CMD || count < 0) + RETURN(NULL); + + size = sizeof(*in_data) + count * sizeof(unsigned int); + OBD_ALLOC(in_data, size); + if (in_data == NULL) + RETURN(NULL); + + memset(in_data, 0, sizeof(*in_data)); + in_data->iocd_size = size; + in_data->iocd_cb = cb; + in_data->iocd_count = count; + memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count); + + down_write(&llioc.ioc_sem); + list_add_tail(&in_data->iocd_list, &llioc.ioc_head); + up_write(&llioc.ioc_sem); + + RETURN(in_data); +} + +void ll_iocontrol_unregister(void *magic) +{ + struct llioc_data *tmp; + + if (magic == NULL) + return; + + down_write(&llioc.ioc_sem); + list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) { + if (tmp == magic) { + unsigned int size = tmp->iocd_size; + + list_del(&tmp->iocd_list); + up_write(&llioc.ioc_sem); + + OBD_FREE(tmp, size); + return; + } + } + up_write(&llioc.ioc_sem); + + CWARN("didn't find iocontrol register block with magic: %p\n", magic); +} + +EXPORT_SYMBOL(ll_iocontrol_register); +EXPORT_SYMBOL(ll_iocontrol_unregister); + +enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file, + unsigned int cmd, unsigned long arg, int *rcp) +{ + enum llioc_iter ret = LLIOC_CONT; + struct llioc_data *data; + int rc = -EINVAL, i; + + down_read(&llioc.ioc_sem); + list_for_each_entry(data, &llioc.ioc_head, iocd_list) { + for (i = 0; i < data->iocd_count; i++) { + if (cmd != data->iocd_cmd[i]) + continue; + + ret = data->iocd_cb(inode, file, cmd, arg, data, &rc); + break; + } + + if (ret == LLIOC_STOP) + break; + } + up_read(&llioc.ioc_sem); + + if (rcp) + *rcp = rc; + return ret; +}