From: pschwan Date: Wed, 20 Mar 2002 19:07:46 +0000 (+0000) Subject: - Removed the (nearly) unused obd_print_entry and fixed the code that X-Git-Tag: 0.4.2~517 X-Git-Url: https://git.whamcloud.com/?a=commitdiff_plain;h=08b2e7403796b46df782af012b421546ffe5e950;p=fs%2Flustre-release.git - Removed the (nearly) unused obd_print_entry and fixed the code that depended on it. - Added code to drop packets based on /proc/sys/obd/drop_packet - De-tabbified and switched a bunch of code to use RETURN and GOTO --- diff --git a/lustre/include/linux/obd_support.h b/lustre/include/linux/obd_support.h index 0d51925..d271fb6 100644 --- a/lustre/include/linux/obd_support.h +++ b/lustre/include/linux/obd_support.h @@ -1,19 +1,65 @@ -#ifndef _OBD_SUPPORT -#define _OBD_SUPPORT -/* - * Copyright (C) 2001 Cluster File Systems, Inc. +/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- + * vim:expandtab:shiftwidth=8:tabstop=8: + * + * Copyright (C) 2001, 2002 Cluster File Systems, Inc. + * + * This file is part of Lustre, http://www.lustre.org. + * + * 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. + * + * 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. + * + * 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. * - * This code is issued under the GNU General Public License. - * See the file COPYING in this distribution */ +#ifndef _OBD_SUPPORT +#define _OBD_SUPPORT + #include #include #include /* global variables */ -extern int obd_debug_level; extern unsigned long obd_memory; +extern unsigned long obd_drop_packet; + +enum { + OBD_INST_MDS_GETATTR = 1, + OBD_INST_MDS_READPAGE, + OBD_INST_MDS_READPAGE_BULK, + OBD_INST_MDS_REINT, + OBD_INST_MDS_OPEN, + OBD_INST_MDS_CLOSE, + OBD_INST_OST_CONNECT, + OBD_INST_OST_DISCONNECT, + OBD_INST_OST_GET_INFO, + OBD_INST_OST_CREATE, + OBD_INST_OST_DESTROY, + OBD_INST_OST_GETATTR, + OBD_INST_OST_SETATTR, + OBD_INST_OST_OPEN, + OBD_INST_OST_CLOSE, + OBD_INST_OST_BRW, + OBD_INST_OST_PUNCH +}; + +#define OBD_CHECK_DROP_PACKET(req, id) \ +do { \ + if (obd_drop_packet != id) \ + break; \ + \ + CDEBUG(D_OTHER, "obd_drop_packet=%d, dropping packet.\n", id); \ + ptlrpc_free_req(req); \ + RETURN(0); \ +} while(0) #define OBD_ALLOC(ptr, size) \ do { \ diff --git a/lustre/llite/super.c b/lustre/llite/super.c index 063af18..02cda54 100644 --- a/lustre/llite/super.c +++ b/lustre/llite/super.c @@ -1,4 +1,6 @@ -/* +/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- + * vim:expandtab:shiftwidth=8:tabstop=8: + * * Lustre Light Super operations * * This code is issued under the GNU General Public License. diff --git a/lustre/mds/handler.c b/lustre/mds/handler.c index 0f038c7..7e77ce7 100644 --- a/lustre/mds/handler.c +++ b/lustre/mds/handler.c @@ -2,18 +2,18 @@ * vim:expandtab:shiftwidth=8:tabstop=8: * * linux/mds/handler.c - * + * * Lustre Metadata Server (mds) request handler - * + * * Copyright (C) 2001, 2002 Cluster File Systems, Inc. * * This code is issued under the GNU General Public License. * See the file COPYING in this distribution * * by Peter Braam - * - * This server is single threaded at present (but can easily be multi threaded). - * + * + * This server is single threaded at present (but can easily be multi threaded) + * */ #define EXPORT_SYMTAB @@ -33,69 +33,64 @@ #include #include -int mds_sendpage(struct ptlrpc_request *req, struct file *file, +int mds_sendpage(struct ptlrpc_request *req, struct file *file, __u64 offset, struct niobuf *dst) { int rc = 0; - mm_segment_t oldfs = get_fs(); + mm_segment_t oldfs = get_fs(); - if (req->rq_peer.peer_nid == 0) { - /* dst->addr is a user address, but in a different task! */ - set_fs(KERNEL_DS); + if (req->rq_peer.peer_nid == 0) { + /* dst->addr is a user address, but in a different task! */ + set_fs(KERNEL_DS); /* FIXME: Can't use file->f_op->read() on a directory */ - rc = generic_file_read(file, (char *)(long)dst->addr, - PAGE_SIZE, &offset); - set_fs(oldfs); + rc = generic_file_read(file, (char *)(long)dst->addr, + PAGE_SIZE, &offset); + set_fs(oldfs); - if (rc != PAGE_SIZE) { + if (rc != PAGE_SIZE) { rc = -EIO; - EXIT; - goto out; + GOTO(out, rc); } EXIT; - } else { + } else { struct ptlrpc_bulk_desc *bulk; - char *buf = NULL; + char *buf = NULL; bulk = ptlrpc_prep_bulk(&req->rq_peer); if (bulk == NULL) { rc = -ENOMEM; - EXIT; - goto out; + GOTO(out, rc); } bulk->b_xid = req->rq_xid; - OBD_ALLOC(buf, PAGE_SIZE); - if (!buf) { + OBD_ALLOC(buf, PAGE_SIZE); + if (!buf) { rc = -ENOMEM; - EXIT; - goto cleanup_bulk; + GOTO(cleanup_bulk, rc); } - set_fs(KERNEL_DS); + set_fs(KERNEL_DS); /* FIXME: Can't use file->f_op->read() on a directory */ //rc = file->f_op->read(file, buf, PAGE_SIZE, &offset); rc = generic_file_read(file, buf, PAGE_SIZE, &offset); - set_fs(oldfs); + set_fs(oldfs); - if (rc != PAGE_SIZE) { + if (rc != PAGE_SIZE) { rc = -EIO; - EXIT; - goto cleanup_buf; + GOTO(cleanup_buf, rc); } - bulk->b_buf = buf; - bulk->b_buflen = PAGE_SIZE; + bulk->b_buf = buf; + bulk->b_buflen = PAGE_SIZE; - rc = ptlrpc_send_bulk(bulk, MDS_BULK_PORTAL); + rc = ptlrpc_send_bulk(bulk, MDS_BULK_PORTAL); wait_event_interruptible(bulk->b_waitq, ptlrpc_check_bulk_sent(bulk)); if (bulk->b_flags == PTL_RPC_INTR) { - EXIT; rc = -EINTR; - goto cleanup_buf; + GOTO(cleanup_buf, rc); } EXIT; @@ -103,433 +98,422 @@ int mds_sendpage(struct ptlrpc_request *req, struct file *file, OBD_FREE(buf, PAGE_SIZE); cleanup_bulk: OBD_FREE(bulk, sizeof(*bulk)); - } + } out: - return rc; + return rc; } struct dentry *mds_fid2dentry(struct mds_obd *mds, struct ll_fid *fid, struct vfsmount **mnt) { - /* stolen from NFS */ - struct super_block *sb = mds->mds_sb; - unsigned long ino = fid->id; - //__u32 generation = fid->generation; - __u32 generation = 0; - struct inode *inode; - struct list_head *lp; - struct dentry *result; - - if (ino == 0) - return ERR_PTR(-ESTALE); - - inode = iget(sb, ino); - if (inode == NULL) - return ERR_PTR(-ENOMEM); - - CDEBUG(D_DENTRY, "--> mds_fid2dentry: sb %p\n", inode->i_sb); - - if (is_bad_inode(inode) - || (generation && inode->i_generation != generation) - ) { - /* we didn't find the right inode.. */ - CERROR("bad inode %lu, link: %d ct: %d or version %u/%u\n", - inode->i_ino, - inode->i_nlink, atomic_read(&inode->i_count), - inode->i_generation, - generation); + /* stolen from NFS */ + struct super_block *sb = mds->mds_sb; + unsigned long ino = fid->id; + //__u32 generation = fid->generation; + __u32 generation = 0; + struct inode *inode; + struct list_head *lp; + struct dentry *result; + + if (ino == 0) + return ERR_PTR(-ESTALE); + + inode = iget(sb, ino); + if (inode == NULL) + return ERR_PTR(-ENOMEM); + + CDEBUG(D_DENTRY, "--> mds_fid2dentry: sb %p\n", inode->i_sb); + + if (is_bad_inode(inode) + || (generation && inode->i_generation != generation) + ) { + /* we didn't find the right inode.. */ + CERROR("bad inode %lu, link: %d ct: %d or version %u/%u\n", + inode->i_ino, + inode->i_nlink, atomic_read(&inode->i_count), + inode->i_generation, + generation); BUG(); - iput(inode); - return ERR_PTR(-ESTALE); - } - - /* now to find a dentry. - * If possible, get a well-connected one - */ - if (mnt) - *mnt = mds->mds_vfsmnt; - spin_lock(&dcache_lock); - for (lp = inode->i_dentry.next; lp != &inode->i_dentry ; lp=lp->next) { - result = list_entry(lp,struct dentry, d_alias); - if (! (result->d_flags & DCACHE_NFSD_DISCONNECTED)) { - dget_locked(result); - result->d_vfs_flags |= DCACHE_REFERENCED; - spin_unlock(&dcache_lock); - iput(inode); - if (mnt) - mntget(*mnt); - return result; - } - } - spin_unlock(&dcache_lock); - result = d_alloc_root(inode); - if (result == NULL) { - iput(inode); - return ERR_PTR(-ENOMEM); - } - if (mnt) - mntget(*mnt); - result->d_flags |= DCACHE_NFSD_DISCONNECTED; - return result; + iput(inode); + return ERR_PTR(-ESTALE); + } + + /* now to find a dentry. + * If possible, get a well-connected one + */ + if (mnt) + *mnt = mds->mds_vfsmnt; + spin_lock(&dcache_lock); + for (lp = inode->i_dentry.next; lp != &inode->i_dentry ; lp=lp->next) { + result = list_entry(lp,struct dentry, d_alias); + if (! (result->d_flags & DCACHE_NFSD_DISCONNECTED)) { + dget_locked(result); + result->d_vfs_flags |= DCACHE_REFERENCED; + spin_unlock(&dcache_lock); + iput(inode); + if (mnt) + mntget(*mnt); + return result; + } + } + spin_unlock(&dcache_lock); + result = d_alloc_root(inode); + if (result == NULL) { + iput(inode); + return ERR_PTR(-ENOMEM); + } + if (mnt) + mntget(*mnt); + result->d_flags |= DCACHE_NFSD_DISCONNECTED; + return result; } static inline void mds_get_objid(struct inode *inode, __u64 *id) { /* FIXME: it is only by luck that this works on ext3 */ - memcpy(id, &inode->u.ext2_i.i_data, sizeof(*id)); + memcpy(id, &inode->u.ext2_i.i_data, sizeof(*id)); } int mds_getattr(struct ptlrpc_request *req) { - struct dentry *de; - struct inode *inode; - struct mds_rep *rep; - int rc; - - rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - EXIT; - CERROR("mds: out of memory\n"); - req->rq_status = -ENOMEM; - return 0; - } - - req->rq_rephdr->xid = req->rq_reqhdr->xid; - rep = req->rq_rep.mds; - - de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, NULL); - if (IS_ERR(de)) { - EXIT; - req->rq_rephdr->status = -ENOENT; - return 0; - } - - inode = de->d_inode; - rep->ino = inode->i_ino; - rep->atime = inode->i_atime; - rep->ctime = inode->i_ctime; - rep->mtime = inode->i_mtime; - rep->uid = inode->i_uid; - rep->gid = inode->i_gid; - rep->size = inode->i_size; - rep->mode = inode->i_mode; - rep->nlink = inode->i_nlink; - rep->valid = ~0; - mds_get_objid(inode, &rep->objid); - dput(de); - return 0; + struct dentry *de; + struct inode *inode; + struct mds_rep *rep; + int rc; + + rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("mds: out of memory\n"); + req->rq_status = -ENOMEM; + RETURN(0); + } + + req->rq_rephdr->xid = req->rq_reqhdr->xid; + rep = req->rq_rep.mds; + + de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, NULL); + if (IS_ERR(de)) { + req->rq_rephdr->status = -ENOENT; + RETURN(0); + } + + inode = de->d_inode; + rep->ino = inode->i_ino; + rep->atime = inode->i_atime; + rep->ctime = inode->i_ctime; + rep->mtime = inode->i_mtime; + rep->uid = inode->i_uid; + rep->gid = inode->i_gid; + rep->size = inode->i_size; + rep->mode = inode->i_mode; + rep->nlink = inode->i_nlink; + rep->valid = ~0; + mds_get_objid(inode, &rep->objid); + dput(de); + return 0; } int mds_open(struct ptlrpc_request *req) { - struct dentry *de; - struct mds_rep *rep; - struct file *file; - struct vfsmount *mnt; - __u32 flags; - int rc; - - rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - EXIT; - CERROR("mds: out of memory\n"); - req->rq_status = -ENOMEM; - return 0; - } - - req->rq_rephdr->xid = req->rq_reqhdr->xid; - rep = req->rq_rep.mds; - - de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, &mnt); - if (IS_ERR(de)) { - EXIT; - req->rq_rephdr->status = -ENOENT; - return 0; - } - flags = req->rq_req.mds->flags; - file = dentry_open(de, mnt, flags); - if (!file || IS_ERR(file)) { - req->rq_rephdr->status = -EINVAL; - return 0; - } - - rep->objid = (__u64) (unsigned long)file; - return 0; + struct dentry *de; + struct mds_rep *rep; + struct file *file; + struct vfsmount *mnt; + __u32 flags; + int rc; + + rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("mds: out of memory\n"); + req->rq_status = -ENOMEM; + RETURN(0); + } + + req->rq_rephdr->xid = req->rq_reqhdr->xid; + rep = req->rq_rep.mds; + + de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, &mnt); + if (IS_ERR(de)) { + req->rq_rephdr->status = -ENOENT; + RETURN(0); + } + flags = req->rq_req.mds->flags; + file = dentry_open(de, mnt, flags); + if (!file || IS_ERR(file)) { + req->rq_rephdr->status = -EINVAL; + RETURN(0); + } + + rep->objid = (__u64) (unsigned long)file; + return 0; } int mds_close(struct ptlrpc_request *req) { - struct dentry *de; - struct mds_rep *rep; - struct file *file; - struct vfsmount *mnt; - int rc; - - rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - EXIT; - CERROR("mds: out of memory\n"); - req->rq_status = -ENOMEM; - return 0; - } - - req->rq_rephdr->xid = req->rq_reqhdr->xid; - rep = req->rq_rep.mds; - - de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, &mnt); - if (IS_ERR(de)) { - EXIT; - req->rq_rephdr->status = -ENOENT; - return 0; - } + struct dentry *de; + struct mds_rep *rep; + struct file *file; + struct vfsmount *mnt; + int rc; + + rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("mds: out of memory\n"); + req->rq_status = -ENOMEM; + RETURN(0); + } + + req->rq_rephdr->xid = req->rq_reqhdr->xid; + rep = req->rq_rep.mds; + + de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, &mnt); + if (IS_ERR(de)) { + req->rq_rephdr->status = -ENOENT; + RETURN(0); + } file = (struct file *)(unsigned long) req->rq_req.mds->objid; - req->rq_rephdr->status = filp_close(file, 0); - dput(de); - return 0; + req->rq_rephdr->status = filp_close(file, 0); + dput(de); + return 0; } int mds_readpage(struct ptlrpc_request *req) { - struct vfsmount *mnt; - struct dentry *de; - struct file *file; - struct niobuf *niobuf; - struct mds_rep *rep; - int rc; - - rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - EXIT; - CERROR("mds: out of memory\n"); - req->rq_status = -ENOMEM; - return 0; - } - - req->rq_rephdr->xid = req->rq_reqhdr->xid; - rep = req->rq_rep.mds; - - de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, &mnt); - if (IS_ERR(de)) { - EXIT; - req->rq_rephdr->status = PTR_ERR(de); - return 0; - } + struct vfsmount *mnt; + struct dentry *de; + struct file *file; + struct niobuf *niobuf; + struct mds_rep *rep; + int rc; + + ENTRY; + + rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("mds: out of memory\n"); + req->rq_status = -ENOMEM; + RETURN(0); + } + + req->rq_rephdr->xid = req->rq_reqhdr->xid; + rep = req->rq_rep.mds; + + de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, &mnt); + if (IS_ERR(de)) { + req->rq_rephdr->status = PTR_ERR(de); + RETURN(0); + } CDEBUG(D_INODE, "ino %ld\n", de->d_inode->i_ino); - file = dentry_open(de, mnt, O_RDONLY | O_LARGEFILE); - /* note: in case of an error, dentry_open puts dentry */ - if (IS_ERR(file)) { - EXIT; - req->rq_rephdr->status = PTR_ERR(file); - return 0; - } - - niobuf = mds_req_tgt(req->rq_req.mds); - - /* to make this asynchronous make sure that the handling function - doesn't send a reply when this function completes. Instead a - callback function would send the reply */ - rc = mds_sendpage(req, file, req->rq_req.mds->size, niobuf); - - filp_close(file, 0); - req->rq_rephdr->status = rc; - EXIT; - return 0; + file = dentry_open(de, mnt, O_RDONLY | O_LARGEFILE); + /* note: in case of an error, dentry_open puts dentry */ + if (IS_ERR(file)) { + req->rq_rephdr->status = PTR_ERR(file); + RETURN(0); + } + + niobuf = mds_req_tgt(req->rq_req.mds); + + /* to make this asynchronous make sure that the handling function + doesn't send a reply when this function completes. Instead a + callback function would send the reply */ + rc = mds_sendpage(req, file, req->rq_req.mds->size, niobuf); + + filp_close(file, 0); + req->rq_rephdr->status = rc; + RETURN(0); } int mds_reint(struct ptlrpc_request *req) { - int rc; - char *buf = mds_req_tgt(req->rq_req.mds); - int len = req->rq_req.mds->tgtlen; - struct mds_update_record rec; - - rc = mds_update_unpack(buf, len, &rec); - if (rc) { - CERROR("invalid record\n"); - req->rq_status = -EINVAL; - return 0; - } - /* rc will be used to interrupt a for loop over multiple records */ - rc = mds_reint_rec(&rec, req); - return 0; + char *buf; + int rc, len; + struct mds_update_record rec; + + buf = mds_req_tgt(req->rq_req.mds); + len = req->rq_req.mds->tgtlen; + + rc = mds_update_unpack(buf, len, &rec); + if (rc) { + CERROR("invalid record\n"); + req->rq_status = -EINVAL; + return 0; + } + /* rc will be used to interrupt a for loop over multiple records */ + rc = mds_reint_rec(&rec, req); + return 0; } int mds_handle(struct obd_device *dev, struct ptlrpc_service *svc, struct ptlrpc_request *req) { - int rc; - struct ptlreq_hdr *hdr; + int rc; + struct ptlreq_hdr *hdr; - ENTRY; + ENTRY; - hdr = (struct ptlreq_hdr *)req->rq_reqbuf; + hdr = (struct ptlreq_hdr *)req->rq_reqbuf; - if (NTOH__u32(hdr->type) != MDS_TYPE_REQ) { - CERROR("lustre_mds: wrong packet type sent %d\n", - NTOH__u32(hdr->type)); - rc = -EINVAL; - goto out; - } + if (NTOH__u32(hdr->type) != MDS_TYPE_REQ) { + CERROR("lustre_mds: wrong packet type sent %d\n", + NTOH__u32(hdr->type)); + rc = -EINVAL; + GOTO(out, rc); + } - rc = mds_unpack_req(req->rq_reqbuf, req->rq_reqlen, - &req->rq_reqhdr, &req->rq_req); - if (rc) { - CERROR("lustre_mds: Invalid request\n"); - EXIT; - goto out; - } + rc = mds_unpack_req(req->rq_reqbuf, req->rq_reqlen, + &req->rq_reqhdr, &req->rq_req); + if (rc) { + CERROR("lustre_mds: Invalid request\n"); + GOTO(out, rc); + } - switch (req->rq_reqhdr->opc) { + switch (req->rq_reqhdr->opc) { - case MDS_GETATTR: - CDEBUG(D_INODE, "getattr\n"); - rc = mds_getattr(req); - break; + case MDS_GETATTR: + CDEBUG(D_INODE, "getattr\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_MDS_GETATTR); + rc = mds_getattr(req); + break; - case MDS_READPAGE: - CDEBUG(D_INODE, "readpage\n"); - rc = mds_readpage(req); - break; + case MDS_READPAGE: + CDEBUG(D_INODE, "readpage\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_MDS_READPAGE); + rc = mds_readpage(req); + break; - case MDS_REINT: - CDEBUG(D_INODE, "reint\n"); - rc = mds_reint(req); - break; + case MDS_REINT: + CDEBUG(D_INODE, "reint\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_MDS_REINT); + rc = mds_reint(req); + break; case MDS_OPEN: CDEBUG(D_INODE, "open\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_MDS_OPEN); rc = mds_open(req); break; case MDS_CLOSE: CDEBUG(D_INODE, "close\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_MDS_CLOSE); rc = mds_close(req); break; - default: - return ptlrpc_error(dev, svc, req); - } + default: + rc = ptlrpc_error(dev, svc, req); + RETURN(rc); + } + EXIT; out: - if (rc) { - CERROR("no header\n"); - return 0; - } - - if( req->rq_status) { - ptlrpc_error(dev, svc, req); - } else { - CDEBUG(D_INODE, "sending reply\n"); - ptlrpc_reply(dev, svc, req); - } - - return 0; + if (rc) { + CERROR("no header\n"); + return 0; + } + + if( req->rq_status) { + ptlrpc_error(dev, svc, req); + } else { + CDEBUG(D_NET, "sending reply\n"); + ptlrpc_reply(dev, svc, req); + } + + return 0; } /* mount the file system (secretly) */ static int mds_setup(struct obd_device *obddev, obd_count len, void *buf) { - struct obd_ioctl_data* data = buf; - struct mds_obd *mds = &obddev->u.mds; - struct vfsmount *mnt; - int err; + struct obd_ioctl_data* data = buf; + struct mds_obd *mds = &obddev->u.mds; + struct vfsmount *mnt; + int err; ENTRY; - mnt = do_kern_mount(data->ioc_inlbuf2, 0, data->ioc_inlbuf1, NULL); - err = PTR_ERR(mnt); + mnt = do_kern_mount(data->ioc_inlbuf2, 0, data->ioc_inlbuf1, NULL); + err = PTR_ERR(mnt); if (IS_ERR(mnt)) { CERROR("do_kern_mount failed: %d\n", err); - EXIT; - return err; - } + RETURN(err); + } - mds->mds_sb = mnt->mnt_root->d_inode->i_sb; - if (!mds->mds_sb) { - EXIT; - return -ENODEV; - } + mds->mds_sb = mnt->mnt_root->d_inode->i_sb; + if (!mds->mds_sb) + RETURN(-ENODEV); - mds->mds_vfsmnt = mnt; + mds->mds_vfsmnt = mnt; mds->mds_fstype = strdup(data->ioc_inlbuf2); - mds->mds_ctxt.pwdmnt = mnt; - mds->mds_ctxt.pwd = mnt->mnt_root; - mds->mds_ctxt.fs = KERNEL_DS; + mds->mds_ctxt.pwdmnt = mnt; + mds->mds_ctxt.pwd = mnt->mnt_root; + mds->mds_ctxt.fs = KERNEL_DS; - mds->mds_service = ptlrpc_init_svc( 64 * 1024, - MDS_REQUEST_PORTAL, - MDC_REPLY_PORTAL, - "self", - mds_unpack_req, - mds_pack_rep, - mds_handle); + mds->mds_service = ptlrpc_init_svc(64 * 1024, + MDS_REQUEST_PORTAL, + MDC_REPLY_PORTAL, + "self", + mds_unpack_req, + mds_pack_rep, + mds_handle); rpc_register_service(mds->mds_service, "self"); - err = ptlrpc_start_thread(obddev, mds->mds_service, "lustre_mds"); - if (err) { + err = ptlrpc_start_thread(obddev, mds->mds_service, "lustre_mds"); + if (err) CERROR("cannot start thread\n"); - } MOD_INC_USE_COUNT; - EXIT; - return 0; -} + RETURN(0); +} static int mds_cleanup(struct obd_device * obddev) { struct super_block *sb; - struct mds_obd *mds = &obddev->u.mds; + struct mds_obd *mds = &obddev->u.mds; ENTRY; - if ( !(obddev->obd_flags & OBD_SET_UP) ) { - EXIT; - return 0; - } + if (!(obddev->obd_flags & OBD_SET_UP)) + RETURN(0); if ( !list_empty(&obddev->obd_gen_clients) ) { CERROR("still has clients!\n"); - EXIT; - return -EBUSY; + RETURN(-EBUSY); } - ptlrpc_stop_thread(mds->mds_service); - rpc_unregister_service(mds->mds_service); + ptlrpc_stop_thread(mds->mds_service); + rpc_unregister_service(mds->mds_service); - if (!list_empty(&mds->mds_service->srv_reqs)) { - // XXX reply with errors and clean up - CERROR("Request list not empty!\n"); - } + if (!list_empty(&mds->mds_service->srv_reqs)) { + // XXX reply with errors and clean up + CERROR("Request list not empty!\n"); + } rpc_unregister_service(mds->mds_service); OBD_FREE(mds->mds_service, sizeof(*mds->mds_service)); sb = mds->mds_sb; - if (!mds->mds_sb){ - EXIT; - return 0; - } + if (!mds->mds_sb) + RETURN(0); - unlock_kernel(); - mntput(mds->mds_vfsmnt); + unlock_kernel(); + mntput(mds->mds_vfsmnt); mds->mds_sb = 0; - kfree(mds->mds_fstype); - lock_kernel(); + kfree(mds->mds_fstype); + lock_kernel(); MOD_DEC_USE_COUNT; - EXIT; - return 0; + RETURN(0); } /* use obd ops to offer management infrastructure */ @@ -541,12 +525,12 @@ static struct obd_ops mds_obd_ops = { static int __init mds_init(void) { obd_register_type(&mds_obd_ops, LUSTRE_MDS_NAME); - return 0; + return 0; } static void __exit mds_exit(void) { - obd_unregister_type(LUSTRE_MDS_NAME); + obd_unregister_type(LUSTRE_MDS_NAME); } MODULE_AUTHOR("Peter J. Braam "); diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c index 3ddce71..5d83a89 100644 --- a/lustre/obdclass/class_obd.c +++ b/lustre/obdclass/class_obd.c @@ -60,9 +60,8 @@ #include static int obd_init_magic; -int obd_print_entry = 1; -int obd_debug_level = ~0; unsigned long obd_memory = 0; +unsigned long obd_drop_packet = 0; struct obd_device obd_dev[MAX_OBD_DEVICES]; struct list_head obd_types; @@ -73,8 +72,7 @@ static int obd_class_open(struct inode * inode, struct file * file) file->private_data = NULL; MOD_INC_USE_COUNT; - EXIT; - return 0; + RETURN(0); } /* closing /dev/obd */ @@ -86,8 +84,7 @@ static int obd_class_release(struct inode * inode, struct file * file) file->private_data = NULL; MOD_DEC_USE_COUNT; - EXIT; - return 0; + RETURN(0); } /* @@ -146,42 +143,38 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, if (!obd && cmd != OBD_IOC_DEVICE && cmd != TCGETS) { CERROR("OBD ioctl: No device\n"); - return -EINVAL; + RETURN(-EINVAL); } if (obd_ioctl_getdata(buf, buf + 800, (void *)arg)) { CERROR("OBD ioctl: data error\n"); - return -EINVAL; + RETURN(-EINVAL); } data = (struct obd_ioctl_data *)buf; switch (cmd) { - case TCGETS: { - EXIT; - return -EINVAL; - } + case TCGETS: + RETURN(-EINVAL); case OBD_IOC_DEVICE: { CDEBUG(D_IOCTL, "\n"); if (data->ioc_dev >= MAX_OBD_DEVICES || data->ioc_dev < 0) { CERROR("OBD ioctl: DEVICE insufficient devices\n"); - return -EINVAL; + RETURN(-EINVAL); } CDEBUG(D_IOCTL, "device %d\n", data->ioc_dev); filp->private_data = &obd_dev[data->ioc_dev]; - EXIT; - return 0; + RETURN(0); } case OBD_IOC_ATTACH: { struct obd_type *type; - ENTRY; /* have we attached a type to this device */ - if ( obd->obd_flags & OBD_ATTACHED ) { + if (obd->obd_flags & OBD_ATTACHED) { CERROR("OBD: Device %d already typed as %s.\n", obd->obd_minor, MKSTR(obd->obd_type->typ_name)); - return -EBUSY; + RETURN(-EBUSY); } CDEBUG(D_IOCTL, "attach %s %s\n", MKSTR(data->ioc_inlbuf1), @@ -189,9 +182,9 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, /* find the type */ type = obd_nm_to_type(data->ioc_inlbuf1); - if ( !type ) { + if (!type) { CERROR("OBD: unknown type dev %d\n", obd->obd_minor); - return -EINVAL; + RETURN(-EINVAL); } obd->obd_type = type; @@ -200,13 +193,11 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, INIT_LIST_HEAD(&obd->obd_req_list); /* do the attach */ - if ( OBT(obd) && OBP(obd, attach) ) { + if (OBT(obd) && OBP(obd, attach)) err = OBP(obd, attach)(obd, sizeof(*data), data); - } - if ( err ) { + if (err) { obd->obd_type = NULL; - EXIT; } else { obd->obd_flags |= OBD_ATTACHED; type->typ_refcnt++; @@ -215,31 +206,30 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, obd->obd_proc_entry = proc_lustre_register_obd_device(obd); MOD_INC_USE_COUNT; - EXIT; } - return err; + RETURN(err); } case OBD_IOC_DETACH: { ENTRY; if (obd->obd_flags & OBD_SET_UP) { CERROR("OBD device %d still set up\n", obd->obd_minor); - return -EBUSY; + RETURN(-EBUSY); } if (! (obd->obd_flags & OBD_ATTACHED) ) { CERROR("OBD device %d not attached\n", obd->obd_minor); - return -ENODEV; + RETURN(-ENODEV); } if ( !list_empty(&obd->obd_gen_clients) ) { CERROR("OBD device %d has connected clients\n", obd->obd_minor); - return -EBUSY; + RETURN(-EBUSY); } if ( !list_empty(&obd->obd_req_list) ) { CERROR("OBD device %d has hanging requests\n", obd->obd_minor); - return -EBUSY; + RETURN(-EBUSY); } if (obd->obd_proc_entry) @@ -249,23 +239,21 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, obd->obd_type->typ_refcnt--; obd->obd_type = NULL; MOD_DEC_USE_COUNT; - EXIT; - return 0; + RETURN(0); } case OBD_IOC_SETUP: { - ENTRY; /* have we attached a type to this device? */ if (!(obd->obd_flags & OBD_ATTACHED)) { CERROR("Device %d not attached\n", obd->obd_minor); - return -ENODEV; + RETURN(-ENODEV); } /* has this been done already? */ if ( obd->obd_flags & OBD_SET_UP ) { CERROR("Device %d already setup (type %s)\n", obd->obd_minor, obd->obd_type->typ_name); - return -EBUSY; + RETURN(-EBUSY); } if ( OBT(obd) && OBP(obd, setup) ) @@ -274,18 +262,15 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, if (!err) { obd->obd_type->typ_refcnt++; obd->obd_flags |= OBD_SET_UP; - EXIT; } - return err; + RETURN(err); } case OBD_IOC_CLEANUP: { - ENTRY; - /* have we attached a type to this device? */ if (!(obd->obd_flags & OBD_ATTACHED)) { CERROR("Device %d not attached\n", obd->obd_minor); - return -ENODEV; + RETURN(-ENODEV); } if ( OBT(obd) && OBP(obd, cleanup) ) @@ -294,13 +279,11 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, if (!err) { obd->obd_flags &= ~OBD_SET_UP; obd->obd_type->typ_refcnt--; - EXIT; } - return err; + RETURN(err); } - case OBD_IOC_CONNECT: - { + case OBD_IOC_CONNECT: { conn.oc_id = data->ioc_conn1; conn.oc_dev = obd; @@ -308,10 +291,11 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, CDEBUG(D_IOCTL, "assigned connection %d\n", conn.oc_id); data->ioc_conn1 = conn.oc_id; - if ( err ) - return err; + if (err) + RETURN(err); - return copy_to_user((int *)arg, data, sizeof(*data)); + err = copy_to_user((int *)arg, data, sizeof(*data)); + RETURN(err); } case OBD_IOC_DISCONNECT: { @@ -319,12 +303,12 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, conn.oc_dev = obd; err = obd_disconnect(&conn); - return err; + RETURN(err); } case OBD_IOC_DEC_USE_COUNT: { MOD_DEC_USE_COUNT; - return 0; + RETURN(0); } case OBD_IOC_CREATE: { @@ -332,14 +316,11 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, conn.oc_dev = obd; err = obd_create(&conn, &data->ioc_obdo1); - if (err) { - EXIT; - return err; - } + if (err) + RETURN(err); err = copy_to_user((int *)arg, data, sizeof(*data)); - EXIT; - return err; + RETURN(err); } case OBD_IOC_GETATTR: { @@ -347,14 +328,11 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, conn.oc_dev = obd; err = obd_getattr(&conn, &data->ioc_obdo1); - if (err) { - EXIT; - return err; - } + if (err) + RETURN(err); err = copy_to_user((int *)arg, data, sizeof(*data)); - EXIT; - return err; + RETURN(err); } case OBD_IOC_SETATTR: { @@ -362,14 +340,11 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, conn.oc_dev = obd; err = obd_setattr(&conn, &data->ioc_obdo1); - if (err) { - EXIT; - return err; - } + if (err) + RETURN(err); err = copy_to_user((int *)arg, data, sizeof(*data)); - EXIT; - return err; + RETURN(err); } case OBD_IOC_DESTROY: { @@ -377,14 +352,11 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, conn.oc_dev = obd; err = obd_destroy(&conn, &data->ioc_obdo1); - if (err) { - EXIT; - return err; - } + if (err) + RETURN(err); err = copy_to_user((int *)arg, data, sizeof(*data)); - EXIT; - return err; + RETURN(err); } case OBD_IOC_BRW_WRITE: @@ -421,9 +393,8 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, flags = kmalloc(pages * sizeof(obd_flag), GFP_KERNEL); if (!bufs || !counts || !offsets || !flags) { CERROR("no memory for %d BRW per-page data\n", pages); - EXIT; err = -ENOMEM; - goto brw_free; + GOTO(brw_free, err); } obdos[0] = &data->ioc_obdo1; @@ -452,8 +423,7 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, */ CERROR("no memory for brw pages\n"); err = -ENOMEM; - EXIT; - goto brw_cleanup; + GOTO(brw_cleanup, err); } bufs[pages] = virt_to_page(to); counts[pages] = PAGE_SIZE; @@ -481,14 +451,11 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, conn.oc_dev = obd; err = obd_iocontrol(cmd, &conn, sizeof(*data), data, NULL); - if (err) { - EXIT; - return err; - } + if (err) + RETURN(err); err = copy_to_user((int *)arg, data, sizeof(*data)); - EXIT; - return err; + RETURN(err); } } } /* obd_class_ioctl */ @@ -499,55 +466,52 @@ int obd_register_type(struct obd_ops *ops, char *nm) { struct obd_type *type; + ENTRY; + if (obd_init_magic != 0x11223344) { CERROR("bad magic for type\n"); - EXIT; - return -EINVAL; + RETURN(-EINVAL); } if ( obd_nm_to_type(nm) ) { CDEBUG(D_IOCTL, "Type %s already registered\n", nm); - EXIT; - return -EEXIST; + RETURN(-EEXIST); } OBD_ALLOC(type, sizeof(*type)); - if ( !type ) { - EXIT; - return -ENOMEM; - } + if (!type) + RETURN(-ENOMEM); memset(type, 0, sizeof(*type)); INIT_LIST_HEAD(&type->typ_chain); MOD_INC_USE_COUNT; list_add(&type->typ_chain, obd_types.next); type->typ_ops = ops; type->typ_name = nm; - EXIT; - return 0; + RETURN(0); } int obd_unregister_type(char *nm) { struct obd_type *type = obd_nm_to_type(nm); + ENTRY; + if ( !type ) { MOD_DEC_USE_COUNT; CERROR("unknown obd type\n"); - EXIT; - return -EINVAL; + RETURN(-EINVAL); } if ( type->typ_refcnt ) { MOD_DEC_USE_COUNT; CERROR("type %s has refcount (%d)\n", nm, type->typ_refcnt); - EXIT; - return -EBUSY; + RETURN(-EBUSY); } list_del(&type->typ_chain); OBD_FREE(type, sizeof(*type)); MOD_DEC_USE_COUNT; - return 0; + RETURN(0); } /* obd_unregister_type */ /* declare character device */ @@ -565,12 +529,9 @@ static struct miscdevice obd_psdev = { &obd_psdev_fops }; - EXPORT_SYMBOL(obd_register_type); EXPORT_SYMBOL(obd_unregister_type); -EXPORT_SYMBOL(obd_print_entry); -EXPORT_SYMBOL(obd_debug_level); EXPORT_SYMBOL(obd_dev); EXPORT_SYMBOL(gen_connect); @@ -584,6 +545,7 @@ EXPORT_SYMBOL(obdo_cachep); EXPORT_SYMBOL(gen_multi_setup); EXPORT_SYMBOL(gen_multi_cleanup); EXPORT_SYMBOL(obd_memory); +EXPORT_SYMBOL(obd_drop_packet); static int __init init_obdclass(void) { @@ -628,7 +590,7 @@ static void __exit cleanup_obdclass(void) OBT(obd) && OBP(obd, detach) ) { /* XXX should this call generic detach otherwise? */ OBP(obd, detach)(obd); - } + } } obd_cleanup_obdo_cache(); diff --git a/lustre/obdclass/sysctl.c b/lustre/obdclass/sysctl.c index 48e1a01..388e8f3 100644 --- a/lustre/obdclass/sysctl.c +++ b/lustre/obdclass/sysctl.c @@ -1,10 +1,23 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Copyright (C) 2001 Cluster File Systems, Inc. + * Copyright (C) 2001, 2002 Cluster File Systems, Inc. + * + * This file is part of Lustre, http://www.lustre.org. + * + * 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. + * + * 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. + * + * 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. * - * This code is issued under the GNU General Public License. - * See the file COPYING in this distribution */ #include @@ -39,18 +52,18 @@ static int obd_sctl_reset( ctl_table * table, int write, struct file #define OBD_SYSCTL 300 -#define OBD_DEBUG 1 /* control debugging */ +#define OBD_DROP_PACKET 1 /* control packet drop instrumentation */ #define OBD_ENTRY 2 /* control enter/leave pattern */ #define OBD_TIMEOUT 3 /* timeout on upcalls to become intrble */ #define OBD_HARD 4 /* mount type "hard" or "soft" */ -#define OBD_VARS 5 +#define OBD_VARS 5 #define OBD_INDEX 6 #define OBD_RESET 7 #define OBD_VARS_SLOT 2 static ctl_table obd_table[] = { - {OBD_DEBUG, "debug", &obd_debug_level, sizeof(int), 0644, NULL, &proc_dointvec}, + {OBD_VARS, "drop_packet", &obd_drop_packet, sizeof(int), 0644, NULL, &proc_dointvec}, {OBD_VARS, "vars", &vars[0], sizeof(int), 0644, NULL, &proc_dointvec}, {OBD_INDEX, "index", &index, sizeof(int), 0644, NULL, &obd_sctl_vars}, {OBD_RESET, "reset", NULL, 0, 0644, NULL, &obd_sctl_reset}, @@ -58,7 +71,7 @@ static ctl_table obd_table[] = { }; static ctl_table parent_table[] = { - {OBD_SYSCTL, "obd", NULL, 0, 0555, obd_table}, + {OBD_SYSCTL, "obd", NULL, 0, 0555, obd_table}, {0} }; diff --git a/lustre/ost/ost_handler.c b/lustre/ost/ost_handler.c index befaf88..7e9d609 100644 --- a/lustre/ost/ost_handler.c +++ b/lustre/ost/ost_handler.c @@ -48,330 +48,312 @@ static int ost_destroy(struct ost_obd *ost, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; + struct obd_conn conn; + int rc; - ENTRY; - - conn.oc_id = req->rq_req.ost->connid; - conn.oc_dev = ost->ost_tgt; - - rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } + ENTRY; - req->rq_rep.ost->result = obd_destroy(&conn, &req->rq_req.ost->oa); + conn.oc_id = req->rq_req.ost->connid; + conn.oc_dev = ost->ost_tgt; - EXIT; - return 0; + rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); + } + + req->rq_rep.ost->result = obd_destroy(&conn, &req->rq_req.ost->oa); + + RETURN(0); } static int ost_getattr(struct ost_obd *ost, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; + struct obd_conn conn; + int rc; - ENTRY; - - conn.oc_id = req->rq_req.ost->connid; - conn.oc_dev = ost->ost_tgt; - - rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } - req->rq_rep.ost->oa.o_id = req->rq_req.ost->oa.o_id; - req->rq_rep.ost->oa.o_valid = req->rq_req.ost->oa.o_valid; + ENTRY; - req->rq_rep.ost->result = obd_getattr(&conn, &req->rq_rep.ost->oa); + conn.oc_id = req->rq_req.ost->connid; + conn.oc_dev = ost->ost_tgt; - EXIT; - return 0; + rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); + } + req->rq_rep.ost->oa.o_id = req->rq_req.ost->oa.o_id; + req->rq_rep.ost->oa.o_valid = req->rq_req.ost->oa.o_valid; + + req->rq_rep.ost->result = obd_getattr(&conn, &req->rq_rep.ost->oa); + + RETURN(0); } static int ost_open(struct ost_obd *ost, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; + struct obd_conn conn; + int rc; - ENTRY; - - conn.oc_id = req->rq_req.ost->connid; - conn.oc_dev = ost->ost_tgt; - - rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } - req->rq_rep.ost->oa.o_id = req->rq_req.ost->oa.o_id; - req->rq_rep.ost->oa.o_valid = req->rq_req.ost->oa.o_valid; + ENTRY; + + conn.oc_id = req->rq_req.ost->connid; + conn.oc_dev = ost->ost_tgt; - req->rq_rep.ost->result = obd_open(&conn, &req->rq_rep.ost->oa); + rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); + } + req->rq_rep.ost->oa.o_id = req->rq_req.ost->oa.o_id; + req->rq_rep.ost->oa.o_valid = req->rq_req.ost->oa.o_valid; + + req->rq_rep.ost->result = obd_open(&conn, &req->rq_rep.ost->oa); - EXIT; - return 0; + RETURN(0); } static int ost_close(struct ost_obd *ost, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; + struct obd_conn conn; + int rc; - ENTRY; - - conn.oc_id = req->rq_req.ost->connid; - conn.oc_dev = ost->ost_tgt; - - rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } - req->rq_rep.ost->oa.o_id = req->rq_req.ost->oa.o_id; - req->rq_rep.ost->oa.o_valid = req->rq_req.ost->oa.o_valid; + ENTRY; - req->rq_rep.ost->result = obd_close(&conn, &req->rq_rep.ost->oa); + conn.oc_id = req->rq_req.ost->connid; + conn.oc_dev = ost->ost_tgt; - EXIT; - return 0; + rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); + } + req->rq_rep.ost->oa.o_id = req->rq_req.ost->oa.o_id; + req->rq_rep.ost->oa.o_valid = req->rq_req.ost->oa.o_valid; + + req->rq_rep.ost->result = obd_close(&conn, &req->rq_rep.ost->oa); + + RETURN(0); } static int ost_create(struct ost_obd *ost, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; + struct obd_conn conn; + int rc; - ENTRY; - - conn.oc_id = req->rq_req.ost->connid; - conn.oc_dev = ost->ost_tgt; - - rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } + ENTRY; + + conn.oc_id = req->rq_req.ost->connid; + conn.oc_dev = ost->ost_tgt; + + rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); + } - memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa, + memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa, sizeof(req->rq_req.ost->oa)); - req->rq_rep.ost->result =obd_create(&conn, &req->rq_rep.ost->oa); + req->rq_rep.ost->result =obd_create(&conn, &req->rq_rep.ost->oa); - EXIT; - return 0; + RETURN(0); } static int ost_punch(struct ost_obd *ost, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; + struct obd_conn conn; + int rc; - ENTRY; - - conn.oc_id = req->rq_req.ost->connid; - conn.oc_dev = ost->ost_tgt; - - rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } + ENTRY; + + conn.oc_id = req->rq_req.ost->connid; + conn.oc_dev = ost->ost_tgt; - memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa, + rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); + } + + memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa, sizeof(req->rq_req.ost->oa)); - req->rq_rep.ost->result = obd_punch(&conn, &req->rq_rep.ost->oa, + req->rq_rep.ost->result = obd_punch(&conn, &req->rq_rep.ost->oa, req->rq_rep.ost->oa.o_size, - req->rq_rep.ost->oa.o_blocks); + req->rq_rep.ost->oa.o_blocks); - EXIT; - return 0; + RETURN(0); } static int ost_setattr(struct ost_obd *ost, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; + struct obd_conn conn; + int rc; - ENTRY; - - conn.oc_id = req->rq_req.ost->connid; - conn.oc_dev = ost->ost_tgt; - - rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } + ENTRY; + + conn.oc_id = req->rq_req.ost->connid; + conn.oc_dev = ost->ost_tgt; + + rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); + } - memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa, - sizeof(req->rq_req.ost->oa)); + memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa, + sizeof(req->rq_req.ost->oa)); - req->rq_rep.ost->result = obd_setattr(&conn, &req->rq_rep.ost->oa); + req->rq_rep.ost->result = obd_setattr(&conn, &req->rq_rep.ost->oa); - EXIT; - return 0; + RETURN(0); } static int ost_connect(struct ost_obd *ost, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; + struct obd_conn conn; + int rc; - ENTRY; - - conn.oc_dev = ost->ost_tgt; - - rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } + ENTRY; + + conn.oc_dev = ost->ost_tgt; - req->rq_rep.ost->result = obd_connect(&conn); + rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); + } + + req->rq_rep.ost->result = obd_connect(&conn); CDEBUG(D_IOCTL, "rep buffer %p, id %d\n", req->rq_repbuf, conn.oc_id); - req->rq_rep.ost->connid = conn.oc_id; - EXIT; - return 0; + req->rq_rep.ost->connid = conn.oc_id; + RETURN(0); } static int ost_disconnect(struct ost_obd *ost, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; + struct obd_conn conn; + int rc; - ENTRY; - - conn.oc_dev = ost->ost_tgt; - conn.oc_id = req->rq_req.ost->connid; - - rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, - &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } + ENTRY; + + conn.oc_dev = ost->ost_tgt; + conn.oc_id = req->rq_req.ost->connid; + + rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, + &req->rq_replen, &req->rq_repbuf); + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); + } CDEBUG(D_IOCTL, "Disconnecting %d\n", conn.oc_id); - req->rq_rep.ost->result = obd_disconnect(&conn); + req->rq_rep.ost->result = obd_disconnect(&conn); - EXIT; - return 0; + RETURN(0); } static int ost_get_info(struct ost_obd *ost, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; - int vallen; - void *val; - char *ptr; + struct obd_conn conn; + int rc; + int vallen; + void *val; + char *ptr; - ENTRY; - - conn.oc_id = req->rq_req.ost->connid; - conn.oc_dev = ost->ost_tgt; - - ptr = ost_req_buf1(req->rq_req.ost); - req->rq_rep.ost->result = obd_get_info(&conn, - req->rq_req.ost->buflen1, ptr, - &vallen, &val); - - rc = ost_pack_rep(val, vallen, NULL, 0, &req->rq_rephdr, - &req->rq_rep, &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } + ENTRY; + + conn.oc_id = req->rq_req.ost->connid; + conn.oc_dev = ost->ost_tgt; + + ptr = ost_req_buf1(req->rq_req.ost); + req->rq_rep.ost->result = obd_get_info(&conn, req->rq_req.ost->buflen1, + ptr, &vallen, &val); + + rc = ost_pack_rep(val, vallen, NULL, 0, &req->rq_rephdr, + &req->rq_rep, &req->rq_replen, &req->rq_repbuf); + if (rc) + CERROR("cannot pack reply\n"); - EXIT; - return 0; + RETURN(rc); } static int ost_brw_read(struct ost_obd *obddev, struct ptlrpc_request *req) { struct ptlrpc_bulk_desc **bulk_vec = NULL; struct ptlrpc_bulk_desc *bulk = NULL; - struct obd_conn conn; - int rc; - int i, j; - int objcount, niocount; - char *tmp1, *tmp2, *end2; - char *res = NULL; - int cmd; - struct niobuf *nb, *src, *dst; - struct obd_ioobj *ioo; - struct ost_req *r = req->rq_req.ost; + struct obd_conn conn; + int rc; + int i, j; + int objcount, niocount; + char *tmp1, *tmp2, *end2; + char *res = NULL; + int cmd; + struct niobuf *nb, *src, *dst; + struct obd_ioobj *ioo; + struct ost_req *r = req->rq_req.ost; - ENTRY; - - tmp1 = ost_req_buf1(r); - tmp2 = ost_req_buf2(r); - end2 = tmp2 + req->rq_req.ost->buflen2; - objcount = r->buflen1 / sizeof(*ioo); - niocount = r->buflen2 / sizeof(*nb); - cmd = r->cmd; + ENTRY; - conn.oc_id = req->rq_req.ost->connid; - conn.oc_dev = req->rq_obd->u.ost.ost_tgt; + tmp1 = ost_req_buf1(r); + tmp2 = ost_req_buf2(r); + end2 = tmp2 + req->rq_req.ost->buflen2; + objcount = r->buflen1 / sizeof(*ioo); + niocount = r->buflen2 / sizeof(*nb); + cmd = r->cmd; + + conn.oc_id = req->rq_req.ost->connid; + conn.oc_dev = req->rq_obd->u.ost.ost_tgt; for (i = 0; i < objcount; i++) { - ost_unpack_ioo((void *)&tmp1, &ioo); - if (tmp2 + ioo->ioo_bufcnt > end2) { + ost_unpack_ioo((void *)&tmp1, &ioo); + if (tmp2 + ioo->ioo_bufcnt > end2) { BUG(); - rc = -EFAULT; - break; - } - for (j = 0; j < ioo->ioo_bufcnt; j++) { - ost_unpack_niobuf((void *)&tmp2, &nb); - } - } + rc = -EFAULT; + break; + } + for (j = 0; j < ioo->ioo_bufcnt; j++) + ost_unpack_niobuf((void *)&tmp2, &nb); + } rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep, &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } - OBD_ALLOC(res, sizeof(struct niobuf) * niocount); - if (res == NULL) { - EXIT; - return -ENOMEM; + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); } + OBD_ALLOC(res, sizeof(struct niobuf) * niocount); + if (res == NULL) + RETURN(-ENOMEM); - /* The unpackers move tmp1 and tmp2, so reset them before using */ - tmp1 = ost_req_buf1(r); - tmp2 = ost_req_buf2(r); - req->rq_rep.ost->result = obd_preprw - (cmd, &conn, objcount, (struct obd_ioobj *)tmp1, - niocount, (struct niobuf *)tmp2, (struct niobuf *)res); + /* The unpackers move tmp1 and tmp2, so reset them before using */ + tmp1 = ost_req_buf1(r); + tmp2 = ost_req_buf2(r); + req->rq_rep.ost->result = obd_preprw + (cmd, &conn, objcount, (struct obd_ioobj *)tmp1, + niocount, (struct niobuf *)tmp2, (struct niobuf *)res); - if (req->rq_rep.ost->result) { - EXIT; - goto out; - } + if (req->rq_rep.ost->result) + GOTO(out, 0); for (i = 0; i < niocount; i++) { bulk = ptlrpc_prep_bulk(&req->rq_peer); if (bulk == NULL) { CERROR("cannot alloc bulk desc\n"); rc = -ENOMEM; - goto out; + GOTO(out, rc); } src = &((struct niobuf *)res)[i]; @@ -380,17 +362,13 @@ static int ost_brw_read(struct ost_obd *obddev, struct ptlrpc_request *req) bulk->b_buf = (void *)(unsigned long)src->addr; bulk->b_buflen = PAGE_SIZE; rc = ptlrpc_send_bulk(bulk, OST_BULK_PORTAL); - if (rc) { - EXIT; - goto out; - } + if (rc) + GOTO(out, rc); wait_event_interruptible(bulk->b_waitq, ptlrpc_check_bulk_sent(bulk)); - if (bulk->b_flags == PTL_RPC_INTR) { - EXIT; - goto out; - } + if (bulk->b_flags == PTL_RPC_INTR) + GOTO(out, 0); OBD_FREE(bulk, sizeof(*bulk)); bulk = NULL; @@ -404,13 +382,14 @@ static int ost_brw_read(struct ost_obd *obddev, struct ptlrpc_request *req) #endif barrier(); - /* The unpackers move tmp1 and tmp2, so reset them before using */ - tmp1 = ost_req_buf1(r); - tmp2 = ost_req_buf2(r); + /* The unpackers move tmp1 and tmp2, so reset them before using */ + tmp1 = ost_req_buf1(r); + tmp2 = ost_req_buf2(r); req->rq_rep.ost->result = obd_commitrw - (cmd, &conn, objcount, (struct obd_ioobj *)tmp1, - niocount, (struct niobuf *)res); + (cmd, &conn, objcount, (struct obd_ioobj *)tmp1, + niocount, (struct niobuf *)res); + EXIT; out: if (res != NULL) OBD_FREE(res, sizeof(struct niobuf) * niocount); @@ -425,8 +404,7 @@ static int ost_brw_read(struct ost_obd *obddev, struct ptlrpc_request *req) niocount * sizeof(struct ptlrpc_bulk_desc *)); } - EXIT; - return 0; + return 0; } static int ost_commit_page(struct obd_conn *conn, struct page *page) @@ -441,10 +419,9 @@ static int ost_commit_page(struct obd_conn *conn, struct page *page) buf.page = page; obj.ioo_bufcnt = 1; - - rc = obd_commitrw(OBD_BRW_WRITE, conn, 1, &obj, 1, &buf); - EXIT; - return rc; + + rc = obd_commitrw(OBD_BRW_WRITE, conn, 1, &obj, 1, &buf); + RETURN(rc); } static int ost_brw_write_cb(struct ptlrpc_bulk_desc *bulk, void *data) @@ -457,66 +434,62 @@ static int ost_brw_write_cb(struct ptlrpc_bulk_desc *bulk, void *data) if (rc) CERROR("ost_commit_page failed: %d\n", rc); - EXIT; - return rc; + RETURN(rc); } int ost_brw_write(struct ost_obd *obddev, struct ptlrpc_request *req) { - struct obd_conn conn; - int rc; - int i, j; - int objcount, niocount; - char *tmp1, *tmp2, *end2; - char *res; - int cmd; - struct niobuf *nb, *dst; - struct obd_ioobj *ioo; - struct ost_req *r = req->rq_req.ost; + struct obd_conn conn; + int rc; + int i, j; + int objcount, niocount; + char *tmp1, *tmp2, *end2; + char *res; + int cmd; + struct niobuf *nb, *dst; + struct obd_ioobj *ioo; + struct ost_req *r = req->rq_req.ost; - ENTRY; - - tmp1 = ost_req_buf1(r); - tmp2 = ost_req_buf2(r); - end2 = tmp2 + req->rq_req.ost->buflen2; - objcount = r->buflen1 / sizeof(*ioo); - niocount = r->buflen2 / sizeof(*nb); - cmd = r->cmd; + ENTRY; + + tmp1 = ost_req_buf1(r); + tmp2 = ost_req_buf2(r); + end2 = tmp2 + req->rq_req.ost->buflen2; + objcount = r->buflen1 / sizeof(*ioo); + niocount = r->buflen2 / sizeof(*nb); + cmd = r->cmd; - conn.oc_id = req->rq_req.ost->connid; - conn.oc_dev = req->rq_obd->u.ost.ost_tgt; + conn.oc_id = req->rq_req.ost->connid; + conn.oc_dev = req->rq_obd->u.ost.ost_tgt; for (i = 0; i < objcount; i++) { - ost_unpack_ioo((void *)&tmp1, &ioo); - if (tmp2 + ioo->ioo_bufcnt > end2) { - rc = -EFAULT; - break; - } - for (j = 0; j < ioo->ioo_bufcnt; j++) { - ost_unpack_niobuf((void *)&tmp2, &nb); - } - } + ost_unpack_ioo((void *)&tmp1, &ioo); + if (tmp2 + ioo->ioo_bufcnt > end2) { + rc = -EFAULT; + break; + } + for (j = 0; j < ioo->ioo_bufcnt; j++) + ost_unpack_niobuf((void *)&tmp2, &nb); + } rc = ost_pack_rep(NULL, 0, NULL, niocount * sizeof(*nb), &req->rq_rephdr, &req->rq_rep, &req->rq_replen, &req->rq_repbuf); - if (rc) { - CERROR("cannot pack reply\n"); - return rc; - } + if (rc) { + CERROR("cannot pack reply\n"); + RETURN(rc); + } res = ost_rep_buf2(req->rq_rep.ost); - /* The unpackers move tmp1 and tmp2, so reset them before using */ - tmp1 = ost_req_buf1(r); - tmp2 = ost_req_buf2(r); - req->rq_rep.ost->result = obd_preprw - (cmd, &conn, objcount, (struct obd_ioobj *)tmp1, - niocount, (struct niobuf *)tmp2, (struct niobuf *)res); + /* The unpackers move tmp1 and tmp2, so reset them before using */ + tmp1 = ost_req_buf1(r); + tmp2 = ost_req_buf2(r); + req->rq_rep.ost->result = obd_preprw + (cmd, &conn, objcount, (struct obd_ioobj *)tmp1, + niocount, (struct niobuf *)tmp2, (struct niobuf *)res); - if (req->rq_rep.ost->result) { - EXIT; - goto out; - } + if (req->rq_rep.ost->result) + GOTO(out, 0); for (i = 0; i < niocount; i++) { struct ptlrpc_bulk_desc *bulk; @@ -526,7 +499,7 @@ int ost_brw_write(struct ost_obd *obddev, struct ptlrpc_request *req) if (bulk == NULL) { CERROR("cannot alloc bulk desc\n"); rc = -ENOMEM; - goto out; + GOTO(out, rc); } spin_lock(&srv->srv_lock); @@ -544,7 +517,7 @@ int ost_brw_write(struct ost_obd *obddev, struct ptlrpc_request *req) bulk->b_portal = OSC_BULK_PORTAL; rc = ptlrpc_register_bulk(bulk); if (rc) - goto out; + GOTO(out, rc); #if 0 /* Local delivery */ @@ -555,15 +528,16 @@ int ost_brw_write(struct ost_obd *obddev, struct ptlrpc_request *req) } barrier(); + EXIT; out: - EXIT; - return 0; + /* FIXME: should we return 'rc' here? */ + return 0; } int ost_brw(struct ost_obd *obddev, struct ptlrpc_request *req) { - struct ost_req *r = req->rq_req.ost; - int cmd = r->cmd; + struct ost_req *r = req->rq_req.ost; + int cmd = r->cmd; if (cmd == OBD_BRW_READ) return ost_brw_read(obddev, req); @@ -571,9 +545,8 @@ int ost_brw(struct ost_obd *obddev, struct ptlrpc_request *req) return ost_brw_write(obddev, req); } -static int ost_handle(struct obd_device *obddev, - struct ptlrpc_service *svc, - struct ptlrpc_request *req) +static int ost_handle(struct obd_device *obddev, struct ptlrpc_service *svc, + struct ptlrpc_request *req) { int rc; struct ost_obd *ost = &obddev->u.ost; @@ -587,171 +560,177 @@ static int ost_handle(struct obd_device *obddev, NTOH__u32(hdr->type)); BUG(); rc = -EINVAL; - goto out; + GOTO(out, rc); } - rc = ost_unpack_req(req->rq_reqbuf, req->rq_reqlen, - &req->rq_reqhdr, &req->rq_req); - if (rc) { - CERROR("lustre_ost: Invalid request\n"); - EXIT; - goto out; - } + rc = ost_unpack_req(req->rq_reqbuf, req->rq_reqlen, + &req->rq_reqhdr, &req->rq_req); + if (rc) { + CERROR("lustre_ost: Invalid request\n"); + GOTO(out, rc); + } - switch (req->rq_reqhdr->opc) { - - case OST_CONNECT: - CDEBUG(D_INODE, "connect\n"); - rc = ost_connect(ost, req); - break; - case OST_DISCONNECT: - CDEBUG(D_INODE, "disconnect\n"); - rc = ost_disconnect(ost, req); - break; - case OST_GET_INFO: - CDEBUG(D_INODE, "get_info\n"); - rc = ost_get_info(ost, req); - break; - case OST_CREATE: - CDEBUG(D_INODE, "create\n"); - rc = ost_create(ost, req); - break; - case OST_DESTROY: - CDEBUG(D_INODE, "destroy\n"); - rc = ost_destroy(ost, req); - break; - case OST_GETATTR: - CDEBUG(D_INODE, "getattr\n"); - rc = ost_getattr(ost, req); - break; - case OST_SETATTR: - CDEBUG(D_INODE, "setattr\n"); - rc = ost_setattr(ost, req); - break; - case OST_OPEN: - CDEBUG(D_INODE, "setattr\n"); - rc = ost_open(ost, req); - break; - case OST_CLOSE: - CDEBUG(D_INODE, "setattr\n"); - rc = ost_close(ost, req); - break; - case OST_BRW: - CDEBUG(D_INODE, "brw\n"); - rc = ost_brw(ost, req); - break; - case OST_PUNCH: - CDEBUG(D_INODE, "punch\n"); - rc = ost_punch(ost, req); - break; - default: - req->rq_status = -ENOTSUPP; - return ptlrpc_error(obddev, svc, req); - } + switch (req->rq_reqhdr->opc) { + + case OST_CONNECT: + CDEBUG(D_INODE, "connect\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_CONNECT); + rc = ost_connect(ost, req); + break; + case OST_DISCONNECT: + CDEBUG(D_INODE, "disconnect\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_DISCONNECT); + rc = ost_disconnect(ost, req); + break; + case OST_GET_INFO: + CDEBUG(D_INODE, "get_info\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_GET_INFO); + rc = ost_get_info(ost, req); + break; + case OST_CREATE: + CDEBUG(D_INODE, "create\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_CREATE); + rc = ost_create(ost, req); + break; + case OST_DESTROY: + CDEBUG(D_INODE, "destroy\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_DESTROY); + rc = ost_destroy(ost, req); + break; + case OST_GETATTR: + CDEBUG(D_INODE, "getattr\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_GETATTR); + rc = ost_getattr(ost, req); + break; + case OST_SETATTR: + CDEBUG(D_INODE, "setattr\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_SETATTR); + rc = ost_setattr(ost, req); + break; + case OST_OPEN: + CDEBUG(D_INODE, "setattr\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_OPEN); + rc = ost_open(ost, req); + break; + case OST_CLOSE: + CDEBUG(D_INODE, "setattr\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_CLOSE); + rc = ost_close(ost, req); + break; + case OST_BRW: + CDEBUG(D_INODE, "brw\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_BRW); + rc = ost_brw(ost, req); + break; + case OST_PUNCH: + CDEBUG(D_INODE, "punch\n"); + OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_PUNCH); + rc = ost_punch(ost, req); + break; + default: + req->rq_status = -ENOTSUPP; + rc = ptlrpc_error(obddev, svc, req); + RETURN(rc); + } + EXIT; out: - req->rq_status = rc; - if (rc) { - CERROR("ost: processing error %d\n", rc); - ptlrpc_error(obddev, svc, req); - } else { - CDEBUG(D_INODE, "sending reply\n"); - ptlrpc_reply(obddev, svc, req); - } + req->rq_status = rc; + if (rc) { + CERROR("ost: processing error %d\n", rc); + ptlrpc_error(obddev, svc, req); + } else { + CDEBUG(D_INODE, "sending reply\n"); + ptlrpc_reply(obddev, svc, req); + } - return 0; + return 0; } /* mount the file system (secretly) */ static int ost_setup(struct obd_device *obddev, obd_count len, - void *buf) - + void *buf) + { - struct obd_ioctl_data* data = buf; - struct ost_obd *ost = &obddev->u.ost; - struct obd_device *tgt; - int err; + struct obd_ioctl_data* data = buf; + struct ost_obd *ost = &obddev->u.ost; + struct obd_device *tgt; + int err; ENTRY; - if (data->ioc_dev < 0 || data->ioc_dev > MAX_OBD_DEVICES) { - EXIT; - return -ENODEV; - } + if (data->ioc_dev < 0 || data->ioc_dev > MAX_OBD_DEVICES) + RETURN(-ENODEV); tgt = &obd_dev[data->ioc_dev]; - ost->ost_tgt = tgt; - if ( ! (tgt->obd_flags & OBD_ATTACHED) || + ost->ost_tgt = tgt; + if ( ! (tgt->obd_flags & OBD_ATTACHED) || ! (tgt->obd_flags & OBD_SET_UP) ){ - CERROR("device not attached or not set up (%d)\n", + CERROR("device not attached or not set up (%d)\n", data->ioc_dev); - EXIT; - return -EINVAL; - } - - ost->ost_conn.oc_dev = tgt; - err = obd_connect(&ost->ost_conn); - if (err) { - CERROR("fail to connect to device %d\n", data->ioc_dev); - return -EINVAL; - } + RETURN(-EINVAL); + } - ost->ost_service = ptlrpc_init_svc( 64 * 1024, + ost->ost_conn.oc_dev = tgt; + err = obd_connect(&ost->ost_conn); + if (err) { + CERROR("fail to connect to device %d\n", data->ioc_dev); + RETURN(-EINVAL); + } + + ost->ost_service = ptlrpc_init_svc( 64 * 1024, OST_REQUEST_PORTAL, OSC_REPLY_PORTAL, - "self", + "self", ost_unpack_req, ost_pack_rep, ost_handle); - if (!ost->ost_service) { - obd_disconnect(&ost->ost_conn); - return -EINVAL; + if (!ost->ost_service) { + obd_disconnect(&ost->ost_conn); + RETURN(-EINVAL); } - + rpc_register_service(ost->ost_service, "self"); - err = ptlrpc_start_thread(obddev, ost->ost_service, "lustre_ost"); - if (err) { - obd_disconnect(&ost->ost_conn); - return -EINVAL; + err = ptlrpc_start_thread(obddev, ost->ost_service, "lustre_ost"); + if (err) { + obd_disconnect(&ost->ost_conn); + RETURN(-EINVAL); } - + MOD_INC_USE_COUNT; - EXIT; - return 0; -} + RETURN(0); +} static int ost_cleanup(struct obd_device * obddev) { - struct ost_obd *ost = &obddev->u.ost; - int err; + struct ost_obd *ost = &obddev->u.ost; + int err; ENTRY; if ( !list_empty(&obddev->obd_gen_clients) ) { CERROR("still has clients!\n"); - EXIT; - return -EBUSY; + RETURN(-EBUSY); } - ptlrpc_stop_thread(ost->ost_service); - rpc_unregister_service(ost->ost_service); + ptlrpc_stop_thread(ost->ost_service); + rpc_unregister_service(ost->ost_service); - if (!list_empty(&ost->ost_service->srv_reqs)) { - // XXX reply with errors and clean up - CERROR("Request list not empty!\n"); - } + if (!list_empty(&ost->ost_service->srv_reqs)) { + // XXX reply with errors and clean up + CERROR("Request list not empty!\n"); + } OBD_FREE(ost->ost_service, sizeof(*ost->ost_service)); - err = obd_disconnect(&ost->ost_conn); - if (err) { - CERROR("lustre ost: fail to disconnect device\n"); - return -EINVAL; - } + err = obd_disconnect(&ost->ost_conn); + if (err) { + CERROR("lustre ost: fail to disconnect device\n"); + RETURN(-EINVAL); + } MOD_DEC_USE_COUNT; - EXIT; - return 0; + RETURN(0); } /* use obd ops to offer management infrastructure */ @@ -763,12 +742,12 @@ static struct obd_ops ost_obd_ops = { static int __init ost_init(void) { obd_register_type(&ost_obd_ops, LUSTRE_OST_NAME); - return 0; + return 0; } static void __exit ost_exit(void) { - obd_unregister_type(LUSTRE_OST_NAME); + obd_unregister_type(LUSTRE_OST_NAME); } MODULE_AUTHOR("Peter J. Braam "); diff --git a/lustre/ptlrpc/niobuf.c b/lustre/ptlrpc/niobuf.c index e941587..4a32a08 100644 --- a/lustre/ptlrpc/niobuf.c +++ b/lustre/ptlrpc/niobuf.c @@ -244,7 +244,7 @@ int ptlrpc_error(struct obd_device *obddev, struct ptlrpc_service *svc, } memset(hdr, 0, sizeof(*hdr)); - + hdr->xid = req->rq_reqhdr->xid; hdr->status = req->rq_status; hdr->type = OST_TYPE_ERR;