/* global variables */
extern unsigned long obd_memory;
-extern unsigned long obd_drop_packet;
+extern unsigned long obd_fail_loc;
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
+ OBD_FAIL_MDS = 0x100,
+ OBD_FAIL_MDS_HANDLE_UNPACK,
+ OBD_FAIL_MDS_GETATTR_NET,
+ OBD_FAIL_MDS_GETATTR_PACK,
+ OBD_FAIL_MDS_READPAGE_NET,
+ OBD_FAIL_MDS_READPAGE_PACK,
+ OBD_FAIL_MDS_READPAGE_BULK_NET,
+ OBD_FAIL_MDS_SENDPAGE,
+ OBD_FAIL_MDS_REINT_NET,
+ OBD_FAIL_MDS_REINT_UNPACK,
+ OBD_FAIL_MDS_REINT_SETATTR,
+ OBD_FAIL_MDS_REINT_SETATTR_WRITE,
+ OBD_FAIL_MDS_REINT_CREATE,
+ OBD_FAIL_MDS_REINT_CREATE_WRITE,
+ OBD_FAIL_MDS_REINT_UNLINK,
+ OBD_FAIL_MDS_REINT_UNLINK_WRITE,
+ OBD_FAIL_MDS_REINT_LINK,
+ OBD_FAIL_MDS_REINT_LINK_WRITE,
+ OBD_FAIL_MDS_REINT_RENAME,
+ OBD_FAIL_MDS_REINT_RENAME_WRITE,
+ OBD_FAIL_MDS_OPEN_NET,
+ OBD_FAIL_MDS_OPEN_PACK,
+ OBD_FAIL_MDS_CLOSE_NET,
+ OBD_FAIL_MDS_CLOSE_PACK,
+
+ OBD_FAIL_OST = 0x200,
+ OBD_FAIL_OST_CONNECT_NET,
+ OBD_FAIL_OST_DISCONNECT_NET,
+ OBD_FAIL_OST_GET_INFO_NET,
+ OBD_FAIL_OST_CREATE_NET,
+ OBD_FAIL_OST_DESTROY_NET,
+ OBD_FAIL_OST_GETATTR_NET,
+ OBD_FAIL_OST_SETATTR_NET,
+ OBD_FAIL_OST_OPEN_NET,
+ OBD_FAIL_OST_CLOSE_NET,
+ OBD_FAIL_OST_BRW_NET,
+ OBD_FAIL_OST_PUNCH_NET,
};
-#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); \
- RETURN(0); \
+/* preparation for a more advanced failure testbed (not functional yet) */
+#define OBD_FAIL_MASK_SYS 0x0000FF00
+#define OBD_FAIL_MASK_LOC (0x000000FF | OBD_FAIL_MASK_SYS)
+#define OBD_FAIL_ONCE 0x80000000
+#define OBD_FAILED 0x40000000
+#define OBD_FAIL_MDS_ALL_NET 0x01000000
+#define OBD_FAIL_OST_ALL_NET 0x02000000
+
+#define OBD_FAIL_CHECK(id) ((obd_fail_loc & OBD_FAIL_MASK_LOC) == (id))
+
+#define OBD_FAIL_RETURN(id, ret) \
+do { \
+ if (OBD_FAIL_CHECK(id)) { \
+ CERROR("obd_fail_loc=%d, fail operation rc=%d\n", id, ret); \
+ RETURN(ret); \
+ } \
} while(0)
+#define OBD_FAIL_WRITE(id) \
+do { \
+ if (OBD_FAIL_CHECK(id)) { \
+ CERROR("obd_fail_loc=%d, fail write operation\n", id); \
+ /* FIXME: do something bad here */ \
+ } \
+} while (0)
+
#define OBD_ALLOC(ptr, size) \
do { \
long s = (size); \
int rc = 0;
mm_segment_t oldfs = get_fs();
+ OBD_FAIL_RETURN(OBD_FAIL_MDS_SENDPAGE, -EIO);
+
if (req->rq_peer.peer_nid == 0) {
struct inode *inode = file->f_dentry->d_inode;
char *buf = (char *)(long)dst->addr;
else if (!strcmp(inode->i_sb->s_type->name, "ext3")) {
struct buffer_head *bh;
- bh = ext3_bread(NULL, inode, offset >> inode->i_blkbits,
+ bh = ext3_bread(NULL, inode,
+ offset >> inode->i_sb->s_blocksize_bits,
0, &rc);
if (bh) {
rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
&req->rq_replen, &req->rq_repbuf);
- if (rc) {
+ if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_GETATTR_PACK)) {
CERROR("mds: out of memory\n");
req->rq_status = -ENOMEM;
RETURN(0);
rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
&req->rq_replen, &req->rq_repbuf);
- if (rc) {
+ if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_OPEN_PACK)) {
CERROR("mds: out of memory\n");
req->rq_status = -ENOMEM;
RETURN(0);
rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
&req->rq_replen, &req->rq_repbuf);
- if (rc) {
+ if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_CLOSE_PACK)) {
CERROR("mds: out of memory\n");
req->rq_status = -ENOMEM;
RETURN(0);
rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
&req->rq_replen, &req->rq_repbuf);
- if (rc) {
+ if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_READPAGE_PACK)) {
CERROR("mds: out of memory\n");
req->rq_status = -ENOMEM;
RETURN(0);
len = req->rq_req.mds->tgtlen;
rc = mds_update_unpack(buf, len, &rec);
- if (rc) {
+ if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNPACK)) {
CERROR("invalid record\n");
req->rq_status = -EINVAL;
- return 0;
+ RETURN(0);
}
/* rc will be used to interrupt a for loop over multiple records */
rc = mds_reint_rec(&rec, req);
rc = mds_unpack_req(req->rq_reqbuf, req->rq_reqlen,
&req->rq_reqhdr, &req->rq_req);
- if (rc) {
+ if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_HANDLE_UNPACK)) {
CERROR("lustre_mds: Invalid request\n");
GOTO(out, rc);
}
case MDS_GETATTR:
CDEBUG(D_INODE, "getattr\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_MDS_GETATTR);
+ OBD_FAIL_RETURN(OBD_FAIL_MDS_GETATTR_NET, 0);
rc = mds_getattr(req);
break;
case MDS_READPAGE:
CDEBUG(D_INODE, "readpage\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_MDS_READPAGE);
+ OBD_FAIL_RETURN(OBD_FAIL_MDS_READPAGE_NET, 0);
rc = mds_readpage(req);
break;
case MDS_REINT:
CDEBUG(D_INODE, "reint\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_MDS_REINT);
+ OBD_FAIL_RETURN(OBD_FAIL_MDS_REINT_NET, 0);
rc = mds_reint(req);
break;
case MDS_OPEN:
CDEBUG(D_INODE, "open\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_MDS_OPEN);
+ OBD_FAIL_RETURN(OBD_FAIL_MDS_OPEN_NET, 0);
rc = mds_open(req);
break;
case MDS_CLOSE:
CDEBUG(D_INODE, "close\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_MDS_CLOSE);
+ OBD_FAIL_RETURN(OBD_FAIL_MDS_CLOSE_NET, 0);
rc = mds_close(req);
break;
static int mds_reint_setattr(struct mds_update_record *rec, struct ptlrpc_request *req)
{
+ struct inode *inode;
struct dentry *de;
de = mds_fid2dentry(&req->rq_obd->u.mds, rec->ur_fid1, NULL);
- if (IS_ERR(de)) {
- req->rq_rephdr->status = -ESTALE;
- return 0;
+ if (IS_ERR(de) || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_SETATTR)) {
+ req->rq_rephdr->status = -ESTALE;
+ RETURN(0);
}
- CDEBUG(D_INODE, "ino %ld\n", de->d_inode->i_ino);
+ inode = de->d_inode;
+ CDEBUG(D_INODE, "ino %ld\n", inode->i_ino);
/* a _really_ horrible hack to avoid removing the data stored
in the block pointers; this data is the object id
if ( rec->ur_iattr.ia_valid & ATTR_SIZE ) {
/* ATTR_SIZE would invoke truncate: clear it */
rec->ur_iattr.ia_valid &= ~ATTR_SIZE;
- de->d_inode->i_size = rec->ur_iattr.ia_size;
+ inode->i_size = rec->ur_iattr.ia_size;
+
+ /* an _even_more_ horrible hack to make this hack work with
+ * ext3. This is because ext3 keeps a separate inode size
+ * until the inode is committed to ensure consistency. This
+ * will also go away with the move to EAs.
+ */
+ if (!strcmp(inode->i_sb->s_type->name, "ext3"))
+ inode->u.ext3_i.i_disksize = inode->i_size;
+
/* make sure _something_ gets set - so new inode
goes to disk (probably won't work over XFS */
- if (!rec->ur_iattr.ia_valid & ATTR_MODE) {
+ if (!rec->ur_iattr.ia_valid & ATTR_MODE) {
rec->ur_iattr.ia_valid |= ATTR_MODE;
- rec->ur_iattr.ia_mode = de->d_inode->i_mode;
+ rec->ur_iattr.ia_mode = inode->i_mode;
}
}
- if ( de->d_inode->i_op->setattr ) {
+ OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_SETATTR_WRITE);
+ if ( inode->i_op->setattr ) {
req->rq_rephdr->status =
- de->d_inode->i_op->setattr(de, &rec->ur_iattr);
- } else {
+ inode->i_op->setattr(de, &rec->ur_iattr);
+ } else {
req->rq_rephdr->status =
- inode_setattr(de->d_inode, &rec->ur_iattr);
+ inode_setattr(inode, &rec->ur_iattr);
}
l_dput(de);
struct ptlrpc_request *req)
{
int type = rec->ur_mode & S_IFMT;
- struct dentry *de;
+ struct dentry *de = NULL;
struct mds_rep *rep = req->rq_rep.mds;
- struct dentry *dchild;
+ struct dentry *dchild = NULL;
int rc;
ENTRY;
de = mds_fid2dentry(&req->rq_obd->u.mds, rec->ur_fid1, NULL);
- if (IS_ERR(de)) {
- req->rq_rephdr->status = -ESTALE;
+ if (IS_ERR(de) || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_CREATE)) {
BUG();
- EXIT;
- return 0;
+ GOTO(out_reint_create, (rc = -ESTALE));
}
CDEBUG(D_INODE, "ino %ld\n", de->d_inode->i_ino);
dchild = lookup_one_len(rec->ur_name, de, rec->ur_namelen - 1);
- rc = PTR_ERR(dchild);
- if (IS_ERR(dchild)) {
- CERROR("child lookup error %d\n", rc);
- dput(de);
- req->rq_rephdr->status = -ESTALE;
+ if (IS_ERR(dchild)) {
+ CERROR("child lookup error %ld\n", PTR_ERR(dchild));
BUG();
- EXIT;
- return 0;
+ GOTO(out_reint_create, (rc = -ESTALE));
}
if (dchild->d_inode) {
CERROR("child exists (dir %ld, name %s)\n",
de->d_inode->i_ino, rec->ur_name);
- dput(de);
- req->rq_rephdr->status = -EEXIST;
BUG();
- EXIT;
- return 0;
+ GOTO(out_reint_create, (rc = -EEXIST));
}
+ OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_CREATE_WRITE);
+
switch (type) {
case S_IFREG: {
rc = vfs_create(de->d_inode, dchild, rec->ur_mode);
}
}
- req->rq_rephdr->status = rc;
if (!rc) {
if (type == S_IFREG)
mds_store_objid(dchild->d_inode, &rec->ur_id);
rep->ino = dchild->d_inode->i_ino;
}
- dput(de);
- dput(dchild);
- EXIT;
- return 0;
+out_reint_create:
+ req->rq_rephdr->status = rc;
+ l_dput(de);
+ l_dput(dchild);
+ RETURN(0);
}
static int mds_reint_unlink(struct mds_update_record *rec,
struct ptlrpc_request *req)
{
- struct dentry *de;
- struct dentry *dchild;
- int rc;
+ struct dentry *de = NULL;
+ struct dentry *dchild = NULL;
+ int rc = 0;
ENTRY;
de = mds_fid2dentry(&req->rq_obd->u.mds, rec->ur_fid1, NULL);
- if (IS_ERR(de)) {
+ if (IS_ERR(de) || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNLINK)) {
BUG();
- req->rq_rephdr->status = -ESTALE;
- EXIT;
- return 0;
+ GOTO(out_unlink, (rc = -ESTALE));
}
CDEBUG(D_INODE, "ino %ld\n", de->d_inode->i_ino);
dchild = lookup_one_len(rec->ur_name, de, rec->ur_namelen - 1);
- rc = PTR_ERR(dchild);
- if (IS_ERR(dchild)) {
- CERROR("child lookup error %d\n", rc);
+ if (IS_ERR(dchild)) {
+ CERROR("child lookup error %ld\n", PTR_ERR(dchild));
BUG();
- dput(de);
- req->rq_rephdr->status = -ESTALE;
- EXIT;
- return 0;
+ GOTO(out_unlink, (rc = -ESTALE));
}
if (!dchild->d_inode) {
CERROR("child doesn't exist (dir %ld, name %s\n",
de->d_inode->i_ino, rec->ur_name);
BUG();
- dput(de);
- req->rq_rephdr->status = -ESTALE;
- EXIT;
- return 0;
+ GOTO(out_unlink, (rc = -ESTALE));
}
+ OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_UNLINK_WRITE);
+
switch (dchild->d_inode->i_mode & S_IFMT) {
case S_IFDIR:
rc = vfs_rmdir(de->d_inode, dchild);
EXIT;
break;
default:
- rc = vfs_unlink(de->d_inode, dchild);
-
+ rc = vfs_unlink(de->d_inode, dchild);
EXIT;
break;
}
- req->rq_rephdr->status = rc;
- dput(de);
- dput(dchild);
- EXIT;
- return 0;
+out_unlink:
+ req->rq_rephdr->status = rc;
+ l_dput(de);
+ l_dput(dchild);
+ RETURN(0);
}
static int mds_reint_link(struct mds_update_record *rec,
struct ptlrpc_request *req)
{
- struct dentry *de_src = NULL;
- struct dentry *de_tgt_dir = NULL;
- struct dentry *dchild = NULL;
- int rc;
- ENTRY;
+ struct dentry *de_src = NULL;
+ struct dentry *de_tgt_dir = NULL;
+ struct dentry *dchild = NULL;
+ int rc = 0;
- rc = -ESTALE;
- de_src = mds_fid2dentry(&req->rq_obd->u.mds, rec->ur_fid1, NULL);
- if (IS_ERR(de_src)) {
- EXIT;
- goto out_link;
- }
+ ENTRY;
+ de_src = mds_fid2dentry(&req->rq_obd->u.mds, rec->ur_fid1, NULL);
+ if (IS_ERR(de_src) || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_LINK)) {
+ GOTO(out_link, (rc = -ESTALE));
+ }
de_tgt_dir = mds_fid2dentry(&req->rq_obd->u.mds, rec->ur_fid2, NULL);
- if (IS_ERR(de_tgt_dir)) {
- EXIT;
- goto out_link;
+ if (IS_ERR(de_tgt_dir)) {
+ GOTO(out_link, (rc = -ESTALE));
}
dchild = lookup_one_len(rec->ur_name, de_tgt_dir, rec->ur_namelen - 1);
- if (IS_ERR(dchild)) {
- CERROR("child lookup error %d\n", rc);
- EXIT;
- goto out_link;
+ if (IS_ERR(dchild)) {
+ CERROR("child lookup error %ld\n", PTR_ERR(dchild));
+ GOTO(out_link, (rc = -ESTALE));
}
if (dchild->d_inode) {
CERROR("child exists (dir %ld, name %s\n",
de_tgt_dir->d_inode->i_ino, rec->ur_name);
- EXIT;
- goto out_link;
+ GOTO(out_link, (rc = -EEXIST));
}
+ OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_LINK_WRITE);
+
rc = vfs_link(de_src, de_tgt_dir->d_inode, dchild);
EXIT;
struct dentry *de_tgtdir = NULL;
struct dentry *de_old = NULL;
struct dentry *de_new = NULL;
- int rc;
+ int rc = 0;
ENTRY;
- rc = -ESTALE;
de_srcdir = mds_fid2dentry(&req->rq_obd->u.mds, rec->ur_fid1, NULL);
- if (IS_ERR(de_srcdir)) {
- EXIT;
- goto out_rename;
+ if (IS_ERR(de_srcdir)) {
+ GOTO(out_rename, (rc = -ESTALE));
}
de_tgtdir = mds_fid2dentry(&req->rq_obd->u.mds, rec->ur_fid2, NULL);
- if (IS_ERR(de_tgtdir)) {
- EXIT;
- goto out_rename;
+ if (IS_ERR(de_tgtdir)) {
+ GOTO(out_rename, (rc = -ESTALE));
}
de_old = lookup_one_len(rec->ur_name, de_srcdir, rec->ur_namelen - 1);
- if (IS_ERR(de_old)) {
- CERROR("child lookup error %d\n", rc);
- EXIT;
- goto out_rename;
+ if (IS_ERR(de_old)) {
+ CERROR("child lookup error %ld\n", PTR_ERR(de_old));
+ GOTO(out_rename, (rc = -ESTALE));
}
de_new = lookup_one_len(rec->ur_tgt, de_tgtdir, rec->ur_tgtlen - 1);
- if (IS_ERR(de_new)) {
- CERROR("child lookup error %d\n", rc);
- EXIT;
- goto out_rename;
+ if (IS_ERR(de_new)) {
+ CERROR("child lookup error %ld\n", PTR_ERR(de_new));
+ GOTO(out_rename, (rc = -ESTALE));
}
+ OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_RENAME_WRITE);
+
rc = vfs_rename(de_srcdir->d_inode, de_old, de_tgtdir->d_inode, de_new);
EXIT;
typedef int (*mds_reinter)(struct mds_update_record *, struct ptlrpc_request*);
-static mds_reinter reinters[REINT_MAX+1] = {
- [REINT_SETATTR] mds_reint_setattr,
- [REINT_CREATE] mds_reint_create,
- [REINT_UNLINK] mds_reint_unlink,
- [REINT_LINK] mds_reint_link,
- [REINT_RENAME] mds_reint_rename
+static mds_reinter reinters[REINT_MAX+1] = {
+ [REINT_SETATTR] mds_reint_setattr,
+ [REINT_CREATE] mds_reint_create,
+ [REINT_UNLINK] mds_reint_unlink,
+ [REINT_LINK] mds_reint_link,
+ [REINT_RENAME] mds_reint_rename
};
int mds_reint_rec(struct mds_update_record *rec, struct ptlrpc_request *req)
{
int rc;
- if (rec->ur_opcode < 0 || rec->ur_opcode > REINT_MAX) {
- CERROR("opcode %d not valid\n",
- rec->ur_opcode);
- rc = req->rq_status = -EINVAL;
- return rc;
+ if (rec->ur_opcode < 0 || rec->ur_opcode > REINT_MAX) {
+ CERROR("opcode %d not valid\n", rec->ur_opcode);
+ rc = req->rq_status = -EINVAL;
+ RETURN(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");
- rc = req->rq_status = -ENOMEM;
- return rc;
+ if (rc) {
+ CERROR("mds: out of memory\n");
+ rc = req->rq_status = -ENOMEM;
+ RETURN(rc);
}
req->rq_rephdr->xid = req->rq_reqhdr->xid;
static int obd_init_magic;
unsigned long obd_memory = 0;
-unsigned long obd_drop_packet = 0;
+unsigned long obd_fail_loc = 0;
struct obd_device obd_dev[MAX_OBD_DEVICES];
struct list_head obd_types;
EXPORT_SYMBOL(gen_multi_setup);
EXPORT_SYMBOL(gen_multi_cleanup);
EXPORT_SYMBOL(obd_memory);
-EXPORT_SYMBOL(obd_drop_packet);
+EXPORT_SYMBOL(obd_fail_loc);
static int __init init_obdclass(void)
{
#define OBD_SYSCTL 300
-#define OBD_DROP_PACKET 1 /* control packet drop instrumentation */
+#define OBD_FAIL_LOC 1 /* control test failures 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_SLOT 2
static ctl_table obd_table[] = {
- {OBD_VARS, "drop_packet", &obd_drop_packet, sizeof(int), 0644, NULL, &proc_dointvec},
+ {OBD_FAIL_LOC, "fail_loc", &obd_fail_loc, 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, "lustre", NULL, 0, 0555, obd_table},
{0}
};
case OST_CONNECT:
CDEBUG(D_INODE, "connect\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_CONNECT);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_CONNECT_NET, 0);
rc = ost_connect(ost, req);
break;
case OST_DISCONNECT:
CDEBUG(D_INODE, "disconnect\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_DISCONNECT);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_DISCONNECT_NET, 0);
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);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_GET_INFO_NET, 0);
rc = ost_get_info(ost, req);
break;
case OST_CREATE:
CDEBUG(D_INODE, "create\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_CREATE);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_CREATE_NET, 0);
rc = ost_create(ost, req);
break;
case OST_DESTROY:
CDEBUG(D_INODE, "destroy\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_DESTROY);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_DESTROY_NET, 0);
rc = ost_destroy(ost, req);
break;
case OST_GETATTR:
CDEBUG(D_INODE, "getattr\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_GETATTR);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_GETATTR_NET, 0);
rc = ost_getattr(ost, req);
break;
case OST_SETATTR:
CDEBUG(D_INODE, "setattr\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_SETATTR);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_SETATTR_NET, 0);
rc = ost_setattr(ost, req);
break;
case OST_OPEN:
CDEBUG(D_INODE, "setattr\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_OPEN);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_OPEN_NET, 0);
rc = ost_open(ost, req);
break;
case OST_CLOSE:
CDEBUG(D_INODE, "setattr\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_CLOSE);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_CLOSE_NET, 0);
rc = ost_close(ost, req);
break;
case OST_BRW:
CDEBUG(D_INODE, "brw\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_BRW);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_BRW_NET, 0);
rc = ost_brw(ost, req);
break;
case OST_PUNCH:
CDEBUG(D_INODE, "punch\n");
- OBD_CHECK_DROP_PACKET(req, OBD_INST_OST_PUNCH);
+ OBD_FAIL_RETURN(OBD_FAIL_OST_PUNCH_NET, 0);
rc = ost_punch(ost, req);
break;
default:
git://git.whamcloud.com / fs / lustre-release.git / commitdiff