for (i = 0; i < npages; i++) {
                page = alloc_pages_node(
                                cfs_cpt_spread_node(lnet_cpt_table(), cpt),
-                               __GFP_ZERO | GFP_IOFS, 0);
+                               GFP_KERNEL | __GFP_ZERO, 0);
                if (page == NULL) {
                        while (--i >= 0)
                                __free_page(rb->rb_kiov[i].kiov_page);
 
                        bulk->bk_iovs[i].kiov_offset = 0;
                        bulk->bk_iovs[i].kiov_len    = len;
                        bulk->bk_iovs[i].kiov_page   =
-                               alloc_page(GFP_IOFS);
+                               alloc_page(GFP_KERNEL);
 
                        if (bulk->bk_iovs[i].kiov_page == NULL) {
                                lstcon_rpc_put(*crpc);
 
                int nob;
 
                pg = alloc_pages_node(cfs_cpt_spread_node(lnet_cpt_table(), cpt),
-                                     GFP_IOFS, 0);
+                                     GFP_KERNEL, 0);
                if (pg == NULL) {
                        CERROR("Can't allocate page %d of %d\n", i, bulk_npg);
                        srpc_free_bulk(bk);
 
        struct libcfs_ioctl_data *data;
        int err = 0;
 
-       LIBCFS_ALLOC_GFP(buf, 1024, GFP_IOFS);
+       LIBCFS_ALLOC_GFP(buf, 1024, GFP_KERNEL);
        if (buf == NULL)
                return -ENOMEM;
 
 
        if (nob > 2 * PAGE_CACHE_SIZE)      /* string must be "sensible" */
                return -EINVAL;
 
-       *str = kmalloc(nob, GFP_IOFS | __GFP_ZERO);
+       *str = kmalloc(nob, GFP_KERNEL | __GFP_ZERO);
        if (*str == NULL)
                return -ENOMEM;
 
 
        struct hlist_head *hash;
        int i;
 
-       hash = kmem_cache_alloc(ll_rmtperm_hash_cachep, GFP_IOFS | __GFP_ZERO);
+       hash = kmem_cache_alloc(ll_rmtperm_hash_cachep, GFP_NOFS | __GFP_ZERO);
        if (!hash)
                return NULL;
 
 
        LASSERT(cfg->cfg_instance != NULL);
        LASSERT(cfg->cfg_sb == cfg->cfg_instance);
 
-       inst = kzalloc(PAGE_CACHE_SIZE, GFP_NOFS);
+       inst = kzalloc(PAGE_CACHE_SIZE, GFP_KERNEL);
        if (!inst)
                return -ENOMEM;
 
        if (cfg->cfg_last_idx == 0) /* the first time */
                nrpages = CONFIG_READ_NRPAGES_INIT;
 
-       pages = kcalloc(nrpages, sizeof(*pages), GFP_NOFS);
+       pages = kcalloc(nrpages, sizeof(*pages), GFP_KERNEL);
        if (pages == NULL) {
                rc = -ENOMEM;
                goto out;
        }
 
        for (i = 0; i < nrpages; i++) {
-               pages[i] = alloc_page(GFP_IOFS);
+               pages[i] = alloc_page(GFP_KERNEL);
                if (pages[i] == NULL) {
                        rc = -ENOMEM;
                        goto out;
        if (cld->cld_cfg.cfg_sb)
                lsi = s2lsi(cld->cld_cfg.cfg_sb);
 
-       env = kzalloc(sizeof(*env), GFP_NOFS);
+       env = kzalloc(sizeof(*env), GFP_KERNEL);
        if (!env)
                return -ENOMEM;
 
 
                  (oa->o_valid & OBD_MD_FLFLAGS) != 0 &&
                  (oa->o_flags & OBD_FL_DEBUG_CHECK) != 0);
 
-       gfp_mask = ((ostid_id(&oa->o_oi) & 2) == 0) ? GFP_IOFS : GFP_HIGHUSER;
+       gfp_mask = ((ostid_id(&oa->o_oi) & 2) == 0) ? GFP_KERNEL : GFP_HIGHUSER;
 
        LASSERT(rw == OBD_BRW_WRITE || rw == OBD_BRW_READ);
        LASSERT(lsm != NULL);
 
 {
        struct osc_extent *ext;
 
-       ext = kmem_cache_alloc(osc_extent_kmem, GFP_IOFS | __GFP_ZERO);
+       ext = kmem_cache_alloc(osc_extent_kmem, GFP_NOFS | __GFP_ZERO);
        if (ext == NULL)
                return NULL;
 
 
 #define GFP_USER       (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL)
 #define GFP_HIGHUSER   (GFP_USER | __GFP_HIGHMEM)
 #define GFP_HIGHUSER_MOVABLE   (GFP_HIGHUSER | __GFP_MOVABLE)
-#define GFP_IOFS       (__GFP_IO | __GFP_FS | __GFP_KSWAPD_RECLAIM)
 #define GFP_TRANSHUGE  ((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \
                         __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN) & \
                         ~__GFP_KSWAPD_RECLAIM)