LU-4357 libcfs: restore __GFP_WAIT flag to memalloc calls

[fs/lustre-release.git] / lustre / ptlrpc / sec.c

diff --git a/lustre/ptlrpc/sec.c b/lustre/ptlrpc/sec.c
index b6f7d07..7966fe3 100644 (file)
--- a/lustre/ptlrpc/sec.c
+++ b/lustre/ptlrpc/sec.c
@@ -158,10 +158,12 @@ struct ptlrpc_sec_policy * sptlrpc_wireflavor2policy(__u32 flavor)
 
 __u32 sptlrpc_name2flavor_base(const char *name)
 {
-        if (!strcmp(name, "null"))
-                return SPTLRPC_FLVR_NULL;
-        if (!strcmp(name, "plain"))
-                return SPTLRPC_FLVR_PLAIN;
+       if (!strcmp(name, "null"))
+               return SPTLRPC_FLVR_NULL;
+       if (!strcmp(name, "plain"))
+               return SPTLRPC_FLVR_PLAIN;
+       if (!strcmp(name, "gssnull"))
+               return SPTLRPC_FLVR_GSSNULL;
         if (!strcmp(name, "krb5n"))
                 return SPTLRPC_FLVR_KRB5N;
         if (!strcmp(name, "krb5a"))
@@ -170,8 +172,12 @@ __u32 sptlrpc_name2flavor_base(const char *name)
                 return SPTLRPC_FLVR_KRB5I;
         if (!strcmp(name, "krb5p"))
                 return SPTLRPC_FLVR_KRB5P;
+       if (!strcmp(name, "ski"))
+               return SPTLRPC_FLVR_SKI;
+       if (!strcmp(name, "skpi"))
+               return SPTLRPC_FLVR_SKPI;
 
-        return SPTLRPC_FLVR_INVALID;
+       return SPTLRPC_FLVR_INVALID;
 }
 EXPORT_SYMBOL(sptlrpc_name2flavor_base);
 
@@ -183,6 +189,8 @@ const char *sptlrpc_flavor2name_base(__u32 flvr)
                 return "null";
         else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_PLAIN))
                 return "plain";
+       else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_GSSNULL))
+               return "gssnull";
         else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_KRB5N))
                 return "krb5n";
         else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_KRB5A))
@@ -191,9 +199,13 @@ const char *sptlrpc_flavor2name_base(__u32 flvr)
                 return "krb5i";
         else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_KRB5P))
                 return "krb5p";
+       else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_SKI))
+               return "ski";
+       else if (base == SPTLRPC_FLVR_BASE(SPTLRPC_FLVR_SKPI))
+               return "skpi";
 
-        CERROR("invalid wire flavor 0x%x\n", flvr);
-        return "invalid";
+       CERROR("invalid wire flavor 0x%x\n", flvr);
+       return "invalid";
 }
 EXPORT_SYMBOL(sptlrpc_flavor2name_base);
 
@@ -890,17 +902,17 @@ void sptlrpc_request_out_callback(struct ptlrpc_request *req)
  */
 int sptlrpc_import_check_ctx(struct obd_import *imp)
 {
-        struct ptlrpc_sec     *sec;
-        struct ptlrpc_cli_ctx *ctx;
-        struct ptlrpc_request *req = NULL;
-        int rc;
-        ENTRY;
+       struct ptlrpc_sec     *sec;
+       struct ptlrpc_cli_ctx *ctx;
+       struct ptlrpc_request *req = NULL;
+       int rc;
+       ENTRY;
 
-        cfs_might_sleep();
+       might_sleep();
 
-        sec = sptlrpc_import_sec_ref(imp);
-        ctx = get_my_ctx(sec);
-        sptlrpc_sec_put(sec);
+       sec = sptlrpc_import_sec_ref(imp);
+       ctx = get_my_ctx(sec);
+       sptlrpc_sec_put(sec);
 
         if (!ctx)
                 RETURN(-ENOMEM);
@@ -916,7 +928,7 @@ int sptlrpc_import_check_ctx(struct obd_import *imp)
                 RETURN(-EACCES);
         }
 
-       req = ptlrpc_request_cache_alloc(__GFP_IO);
+       req = ptlrpc_request_cache_alloc(GFP_NOFS);
        if (!req)
                RETURN(-ENOMEM);
 
@@ -1088,14 +1100,14 @@ int sptlrpc_cli_unwrap_reply(struct ptlrpc_request *req)
  * changed at any time, no matter we're holding rq_lock or not. For this reason
  * we allocate a separate ptlrpc_request and reply buffer for early reply
  * processing.
- * 
+ *
  * \retval 0 success, \a req_ret is filled with a duplicated ptlrpc_request.
  * Later the caller must call sptlrpc_cli_finish_early_reply() on the returned
  * \a *req_ret to release it.
  * \retval -ev error number, and \a req_ret will not be set.
  */
 int sptlrpc_cli_unwrap_early_reply(struct ptlrpc_request *req,
-                                   struct ptlrpc_request **req_ret)
+                                  struct ptlrpc_request **req_ret)
 {
        struct ptlrpc_request  *early_req;
        char                   *early_buf;
@@ -1103,17 +1115,17 @@ int sptlrpc_cli_unwrap_early_reply(struct ptlrpc_request *req,
        int                     rc;
        ENTRY;
 
-       early_req = ptlrpc_request_cache_alloc(__GFP_IO);
-        if (early_req == NULL)
-                RETURN(-ENOMEM);
+       early_req = ptlrpc_request_cache_alloc(GFP_NOFS);
+       if (early_req == NULL)
+               RETURN(-ENOMEM);
 
-        early_size = req->rq_nob_received;
-        early_bufsz = size_roundup_power2(early_size);
-        OBD_ALLOC_LARGE(early_buf, early_bufsz);
-        if (early_buf == NULL)
-                GOTO(err_req, rc = -ENOMEM);
+       early_size = req->rq_nob_received;
+       early_bufsz = size_roundup_power2(early_size);
+       OBD_ALLOC_LARGE(early_buf, early_bufsz);
+       if (early_buf == NULL)
+               GOTO(err_req, rc = -ENOMEM);
 
-        /* sanity checkings and copy data out, do it inside spinlock */
+       /* sanity checkings and copy data out, do it inside spinlock */
        spin_lock(&req->rq_lock);
 
        if (req->rq_replied) {
@@ -1405,20 +1417,20 @@ int sptlrpc_import_sec_adapt(struct obd_import *imp,
                              struct ptlrpc_svc_ctx *svc_ctx,
                              struct sptlrpc_flavor *flvr)
 {
-        struct ptlrpc_connection   *conn;
-        struct sptlrpc_flavor       sf;
-        struct ptlrpc_sec          *sec, *newsec;
-        enum lustre_sec_part        sp;
-        char                        str[24];
-        int                         rc = 0;
-        ENTRY;
+       struct ptlrpc_connection   *conn;
+       struct sptlrpc_flavor       sf;
+       struct ptlrpc_sec          *sec, *newsec;
+       enum lustre_sec_part        sp;
+       char                        str[24];
+       int                         rc = 0;
+       ENTRY;
 
-        cfs_might_sleep();
+       might_sleep();
 
-        if (imp == NULL)
-                RETURN(0);
+       if (imp == NULL)
+               RETURN(0);
 
-        conn = imp->imp_connection;
+       conn = imp->imp_connection;
 
         if (svc_ctx == NULL) {
                 struct client_obd *cliobd = &imp->imp_obd->u.cli;
@@ -2107,8 +2119,18 @@ int sptlrpc_svc_alloc_rs(struct ptlrpc_request *req, int msglen)
 
         rc = policy->sp_sops->alloc_rs(req, msglen);
         if (unlikely(rc == -ENOMEM)) {
+               struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt;
+               if (svcpt->scp_service->srv_max_reply_size <
+                  msglen + sizeof(struct ptlrpc_reply_state)) {
+                       /* Just return failure if the size is too big */
+                       CERROR("size of message is too big (%zd), %d allowed",
+                               msglen + sizeof(struct ptlrpc_reply_state),
+                               svcpt->scp_service->srv_max_reply_size);
+                       RETURN(-ENOMEM);
+               }
+
                 /* failed alloc, try emergency pool */
-               rs = lustre_get_emerg_rs(req->rq_rqbd->rqbd_svcpt);
+               rs = lustre_get_emerg_rs(svcpt);
                 if (rs == NULL)
                         RETURN(-ENOMEM);