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
-#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 <linux/autoconf.h>
#include <linux/slab.h>
#include <linux/kp30.h>
/* 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 { \
-/*
+/* -*- 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.
* 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 <braam@clusterfs.com>
- *
- * 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
#include <linux/lustre_mds.h>
#include <linux/lustre_lib.h>
-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;
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 */
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 <braam@clusterfs.com>");
#include <linux/obd_class.h>
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;
file->private_data = NULL;
MOD_INC_USE_COUNT;
- EXIT;
- return 0;
+ RETURN(0);
}
/* closing /dev/obd */
file->private_data = NULL;
MOD_DEC_USE_COUNT;
- EXIT;
- return 0;
+ RETURN(0);
}
/*
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),
/* 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;
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++;
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)
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) )
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) )
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;
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: {
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: {
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: {
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: {
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: {
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:
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;
*/
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;
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 */
{
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 */
&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);
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)
{
OBT(obd) && OBP(obd, detach) ) {
/* XXX should this call generic detach otherwise? */
OBP(obd, detach)(obd);
- }
+ }
}
obd_cleanup_obdo_cache();
/* -*- 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 <linux/module.h>
#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},
};
static ctl_table parent_table[] = {
- {OBD_SYSCTL, "obd", NULL, 0, 0555, obd_table},
+ {OBD_SYSCTL, "obd", NULL, 0, 0555, obd_table},
{0}
};
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];
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;
#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);
niocount * sizeof(struct ptlrpc_bulk_desc *));
}
- EXIT;
- return 0;
+ return 0;
}
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)
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;
if (bulk == NULL) {
CERROR("cannot alloc bulk desc\n");
rc = -ENOMEM;
- goto out;
+ GOTO(out, rc);
}
spin_lock(&srv->srv_lock);
bulk->b_portal = OSC_BULK_PORTAL;
rc = ptlrpc_register_bulk(bulk);
if (rc)
- goto out;
+ GOTO(out, rc);
#if 0
/* Local delivery */
}
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);
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;
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 */
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 <braam@clusterfs.com>");
}
memset(hdr, 0, sizeof(*hdr));
-
+
hdr->xid = req->rq_reqhdr->xid;
hdr->status = req->rq_status;
hdr->type = OST_TYPE_ERR;
git://git.whamcloud.com / fs / lustre-release.git / commitdiff