--- initial
+++ final
@@ -1,86 +1,86 @@
 static int osc_set_info_async(const struct lu_env *env, struct obd_export *exp, u32 keylen, void *key, u32 vallen, void *val, struct ptlrpc_request_set *set) {
   struct ptlrpc_request *req;
   struct obd_device *obd = exp->exp_obd;
   struct obd_import *imp = class_exp2cliimp(exp);
   char *tmp;
   int rc;
   OBD_FAIL_TIMEOUT(OBD_FAIL_OSC_SHUTDOWN, 10);
   if (KEY_IS(KEY_CHECKSUM)) {
     if (vallen != sizeof(int)) return -EINVAL;
     exp->exp_obd->u.cli.cl_checksum = (*(int *)val) ? 1 : 0;
     return 0;
   }
   if (KEY_IS(KEY_SPTLRPC_CONF)) {
     sptlrpc_conf_client_adapt(obd);
     return 0;
   }
   if (KEY_IS(KEY_FLUSH_CTX)) {
     sptlrpc_import_flush_my_ctx(imp);
     return 0;
   }
   if (KEY_IS(KEY_CACHE_SET)) {
     struct client_obd *cli = &obd->u.cli;
     LASSERT(!cli->cl_cache); /* only once */
     cli->cl_cache = val;
     cl_cache_incref(cli->cl_cache);
     cli->cl_lru_left = &cli->cl_cache->ccc_lru_left;
     /* add this osc into entity list */
     LASSERT(list_empty(&cli->cl_lru_osc));
     spin_lock(&cli->cl_cache->ccc_lru_lock);
     list_add(&cli->cl_lru_osc, &cli->cl_cache->ccc_lru);
     spin_unlock(&cli->cl_cache->ccc_lru_lock);
     return 0;
   }
   if (KEY_IS(KEY_CACHE_LRU_SHRINK)) {
     struct client_obd *cli = &obd->u.cli;
     long nr = atomic_long_read(&cli->cl_lru_in_list) >> 1;
     long target = *(long *)val;
     nr = osc_lru_shrink(env, cli, min(nr, target), true);
     *(long *)val -= nr;
     return 0;
   }
   if (!set && !KEY_IS(KEY_GRANT_SHRINK)) return -EINVAL;
   /* We pass all other commands directly to OST. Since nobody calls osc
    * methods directly and everybody is supposed to go through LOV, we
    * assume lov checked invalid values for us.
    * The only recognised values so far are evict_by_nid and mds_conn.
    * Even if something bad goes through, we'd get a -EINVAL from OST
    * anyway.
    */
   req = ptlrpc_request_alloc(imp, KEY_IS(KEY_GRANT_SHRINK) ? &RQF_OST_SET_GRANT_INFO : &RQF_OBD_SET_INFO);
   if (!req) return -ENOMEM;
   req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY, RCL_CLIENT, keylen);
   if (!KEY_IS(KEY_GRANT_SHRINK)) req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL, RCL_CLIENT, vallen);
   rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_SET_INFO);
   if (rc) {
     ptlrpc_request_free(req);
     return rc;
   }
   tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
   memcpy(tmp, key, keylen);
   tmp = req_capsule_client_get(&req->rq_pill, KEY_IS(KEY_GRANT_SHRINK) ? &RMF_OST_BODY : &RMF_SETINFO_VAL);
   memcpy(tmp, val, vallen);
   if (KEY_IS(KEY_GRANT_SHRINK)) {
     struct osc_brw_async_args *aa;
     struct obdo *oa;
-    CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
+    BUILD_BUG_ON(sizeof(*aa) > sizeof(req->rq_async_args));
     aa = ptlrpc_req_async_args(req);
     oa = kmem_cache_zalloc(obdo_cachep, GFP_NOFS);
     if (!oa) {
       ptlrpc_req_finished(req);
       return -ENOMEM;
     }
     *oa = ((struct ost_body *)val)->oa;
     aa->aa_oa = oa;
     req->rq_interpret_reply = osc_shrink_grant_interpret;
   }
   ptlrpc_request_set_replen(req);
   if (!KEY_IS(KEY_GRANT_SHRINK)) {
     LASSERT(set);
     ptlrpc_set_add_req(set, req);
     ptlrpc_check_set(NULL, set);
   } else {
     ptlrpcd_add_req(req);
   }
   return 0;
 }<sep>@@
expression e1,e2;
@@
-               CLASSERT(e1 <= e2);
+               BUILD_BUG_ON(e1 > e2);