LU-3751 ost: disable OUT_PORTAL request handler on OST.

[fs/lustre-release.git] / lustre / ost / ost_handler.c

diff --git a/lustre/ost/ost_handler.c b/lustre/ost/ost_handler.c
index 9a97778..405d69c 100644 (file)
--- a/lustre/ost/ost_handler.c
+++ b/lustre/ost/ost_handler.c
@@ -446,7 +446,7 @@ static int ost_punch(struct obd_export *exp, struct ptlrpc_request *req,
         /* standard truncate optimization: if file body is completely
          * destroyed, don't send data back to the server. */
         if (body->oa.o_size == 0)
-                flags |= LDLM_AST_DISCARD_DATA;
+               flags |= LDLM_FL_AST_DISCARD_DATA;
 
         repbody = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY);
         repbody->oa = body->oa;
@@ -1064,7 +1064,7 @@ static int ost_brw_write(struct ptlrpc_request *req, struct obd_trans_info *oti)
 
         if ((remote_nb[0].flags & OBD_BRW_MEMALLOC) &&
             (exp->exp_connection->c_peer.nid == exp->exp_connection->c_self))
-                cfs_memory_pressure_set();
+               memory_pressure_set();
 
         if (body->oa.o_valid & OBD_MD_FLOSSCAPA) {
                 capa = req_capsule_client_get(&req->rq_pill, &RMF_CAPA1);
@@ -1247,7 +1247,7 @@ out:
                               obd_uuid2str(&exp->exp_client_uuid),
                               obd_export_nid2str(exp), rc);
         }
-        cfs_memory_pressure_clr();
+       memory_pressure_clr();
         RETURN(rc);
 }
 
@@ -1348,8 +1348,10 @@ static int lock_region(struct obd_export *exp, struct obdo *oa,
                return -ENOMEM;
 
        rc = ost_lock_get(exp, oa, begin, end - begin, &region->lh, LCK_PR, 0);
-       if (rc)
+       if (rc) {
+               OBD_FREE_PTR(region);
                return rc;
+       }
 
        CDEBUG(D_OTHER, "ost lock [%llu,%llu], lh=%p\n",
               begin, end, &region->lh);
@@ -1817,15 +1819,6 @@ int ost_msg_check_version(struct lustre_msg *msg)
                                lustre_msg_get_version(msg),
                                LUSTRE_OBD_VERSION);
                 break;
-       case SEQ_QUERY:
-               /* Note: client always use MDS_VERSION for FID request */
-               rc = lustre_msg_check_version(msg, LUSTRE_MDS_VERSION);
-               if (rc)
-                       CERROR("bad opc %u version %08x, expecting %08x\n",
-                              lustre_msg_get_opc(msg),
-                              lustre_msg_get_version(msg),
-                              LUSTRE_MDS_VERSION);
-               break;
         case OST_CREATE:
         case OST_DESTROY:
         case OST_GETATTR:
@@ -1908,7 +1901,7 @@ static void ost_prolong_lock_one(struct ost_prolong_data *opd,
 {
        LASSERT(lock->l_export == opd->opd_exp);
 
-       if (lock->l_destroyed) /* lock already cancelled */
+       if (lock->l_flags & LDLM_FL_DESTROYED) /* lock already cancelled */
                return;
 
         /* XXX: never try to grab resource lock here because we're inside
@@ -2461,10 +2454,6 @@ int ost_handle(struct ptlrpc_request *req)
                 req_capsule_set(&req->rq_pill, &RQF_OST_GET_INFO_GENERIC);
                 rc = ost_get_info(req->rq_export, req);
                 break;
-       case SEQ_QUERY:
-               CDEBUG(D_INODE, "seq\n");
-               rc = seq_handle(req);
-               break;
         case OST_QUOTACHECK:
                 CDEBUG(D_INODE, "quotacheck\n");
                 req_capsule_set(&req->rq_pill, &RQF_OST_QUOTACHECK);
@@ -2494,19 +2483,6 @@ int ost_handle(struct ptlrpc_request *req)
                 if (rc)
                         RETURN(rc);
                 RETURN(ptlrpc_reply(req));
-        case OBD_LOG_CANCEL:
-                CDEBUG(D_INODE, "log cancel\n");
-                req_capsule_set(&req->rq_pill, &RQF_LOG_CANCEL);
-                if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_NET))
-                        RETURN(0);
-                rc = llog_origin_handle_cancel(req);
-                if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_REP))
-                        RETURN(0);
-                req->rq_status = rc;
-                rc = req_capsule_server_pack(&req->rq_pill);
-                if (rc)
-                        RETURN(rc);
-                RETURN(ptlrpc_reply(req));
        case LDLM_ENQUEUE:
                CDEBUG(D_INODE, "enqueue\n");
                req_capsule_set(&req->rq_pill, &RQF_LDLM_ENQUEUE);
@@ -2797,7 +2773,7 @@ static int ost_setup(struct obd_device *obd, struct lustre_cfg* lcfg)
                        .cc_pattern          = oss_cpts,
                },
                .psc_ops                = {
-                       .so_req_handler         = ost_handle,
+                       .so_req_handler         = tgt_request_handle,
                        .so_req_printer         = target_print_req,
                        .so_hpreq_handler       = NULL,
                },
@@ -2811,9 +2787,55 @@ static int ost_setup(struct obd_device *obd, struct lustre_cfg* lcfg)
                GOTO(out_io, rc);
        }
 
-        ping_evictor_start();
+#if 0
+       /* Object update service */
+       memset(&svc_conf, 0, sizeof(svc_conf));
+       svc_conf = (typeof(svc_conf)) {
+               .psc_name               = "ost_out",
+               .psc_watchdog_factor    = OSS_SERVICE_WATCHDOG_FACTOR,
+               .psc_buf                = {
+                       .bc_nbufs               = OST_NBUFS,
+                       .bc_buf_size            = OUT_BUFSIZE,
+                       .bc_req_max_size        = OUT_MAXREQSIZE,
+                       .bc_rep_max_size        = OUT_MAXREPSIZE,
+                       .bc_req_portal          = OUT_PORTAL,
+                       .bc_rep_portal          = OSC_REPLY_PORTAL,
+               },
+               /*
+                * We'd like to have a mechanism to set this on a per-device
+                * basis, but alas...
+                */
+               .psc_thr                = {
+                       .tc_thr_name            = "ll_ost_out",
+                       .tc_thr_factor          = OSS_CR_THR_FACTOR,
+                       .tc_nthrs_init          = OSS_CR_NTHRS_INIT,
+                       .tc_nthrs_base          = OSS_CR_NTHRS_BASE,
+                       .tc_nthrs_max           = OSS_CR_NTHRS_MAX,
+                       .tc_nthrs_user          = oss_num_create_threads,
+                       .tc_cpu_affinity        = 1,
+                       .tc_ctx_tags            = LCT_DT_THREAD,
+               },
+               .psc_cpt                = {
+                       .cc_pattern             = oss_cpts,
+               },
+               .psc_ops                = {
+                       .so_req_handler         = tgt_request_handle,
+                       .so_req_printer         = target_print_req,
+                       .so_hpreq_handler       = NULL,
+               },
+       };
+       ost->ost_out_service = ptlrpc_register_service(&svc_conf,
+                                                      obd->obd_proc_entry);
+       if (IS_ERR(ost->ost_out_service)) {
+               rc = PTR_ERR(ost->ost_out_service);
+               CERROR("failed to start out service: %d\n", rc);
+               ost->ost_out_service = NULL;
+               GOTO(out_seq, rc);
+       }
+#endif
+       ping_evictor_start();
 
-        RETURN(0);
+       RETURN(0);
 out_io:
        ptlrpc_unregister_service(ost->ost_io_service);
        ost->ost_io_service = NULL;
@@ -2844,10 +2866,14 @@ static int ost_cleanup(struct obd_device *obd)
        ptlrpc_unregister_service(ost->ost_create_service);
        ptlrpc_unregister_service(ost->ost_io_service);
        ptlrpc_unregister_service(ost->ost_seq_service);
+#if 0
+       ptlrpc_unregister_service(ost->ost_out_service);
+#endif
        ost->ost_service = NULL;
        ost->ost_create_service = NULL;
        ost->ost_io_service = NULL;
        ost->ost_seq_service = NULL;
+       ost->ost_out_service = NULL;
 
        mutex_unlock(&ost->ost_health_mutex);
 
@@ -2902,7 +2928,7 @@ static int __init ost_init(void)
         int rc;
         ENTRY;
 
-       ost_page_to_corrupt = cfs_alloc_page(CFS_ALLOC_STD);
+       ost_page_to_corrupt = alloc_page(GFP_IOFS);
 
         lprocfs_ost_init_vars(&lvars);
         rc = class_register_type(&ost_obd_ops, NULL, lvars.module_vars,