• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include <linux/mm.h>
19 #include <linux/highmem.h>
20 #include <linux/slab.h>
21 #include <linux/swap.h>
22 #include <linux/blkdev.h>
23 #include <linux/backing-dev.h>
24 #include "kmem.h"
25 #include "xfs_message.h"
26 
27 void *
kmem_alloc(size_t size,xfs_km_flags_t flags)28 kmem_alloc(size_t size, xfs_km_flags_t flags)
29 {
30 	int	retries = 0;
31 	gfp_t	lflags = kmem_flags_convert(flags);
32 	void	*ptr;
33 
34 	do {
35 		ptr = kmalloc(size, lflags);
36 		if (ptr || (flags & (KM_MAYFAIL|KM_NOSLEEP)))
37 			return ptr;
38 		if (!(++retries % 100))
39 			xfs_err(NULL,
40 	"%s(%u) possible memory allocation deadlock size %u in %s (mode:0x%x)",
41 				current->comm, current->pid,
42 				(unsigned int)size, __func__, lflags);
43 		congestion_wait(BLK_RW_ASYNC, HZ/50);
44 	} while (1);
45 }
46 
47 void *
kmem_zalloc_large(size_t size,xfs_km_flags_t flags)48 kmem_zalloc_large(size_t size, xfs_km_flags_t flags)
49 {
50 	unsigned noio_flag = 0;
51 	void	*ptr;
52 	gfp_t	lflags;
53 
54 	ptr = kmem_zalloc(size, flags | KM_MAYFAIL);
55 	if (ptr)
56 		return ptr;
57 
58 	/*
59 	 * __vmalloc() will allocate data pages and auxillary structures (e.g.
60 	 * pagetables) with GFP_KERNEL, yet we may be under GFP_NOFS context
61 	 * here. Hence we need to tell memory reclaim that we are in such a
62 	 * context via PF_MEMALLOC_NOIO to prevent memory reclaim re-entering
63 	 * the filesystem here and potentially deadlocking.
64 	 */
65 	if ((current->flags & PF_FSTRANS) || (flags & KM_NOFS))
66 		noio_flag = memalloc_noio_save();
67 
68 	lflags = kmem_flags_convert(flags);
69 	ptr = __vmalloc(size, lflags | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL);
70 
71 	if ((current->flags & PF_FSTRANS) || (flags & KM_NOFS))
72 		memalloc_noio_restore(noio_flag);
73 
74 	return ptr;
75 }
76 
77 void *
kmem_realloc(const void * old,size_t newsize,xfs_km_flags_t flags)78 kmem_realloc(const void *old, size_t newsize, xfs_km_flags_t flags)
79 {
80 	int	retries = 0;
81 	gfp_t	lflags = kmem_flags_convert(flags);
82 	void	*ptr;
83 
84 	do {
85 		ptr = krealloc(old, newsize, lflags);
86 		if (ptr || (flags & (KM_MAYFAIL|KM_NOSLEEP)))
87 			return ptr;
88 		if (!(++retries % 100))
89 			xfs_err(NULL,
90 	"%s(%u) possible memory allocation deadlock size %zu in %s (mode:0x%x)",
91 				current->comm, current->pid,
92 				newsize, __func__, lflags);
93 		congestion_wait(BLK_RW_ASYNC, HZ/50);
94 	} while (1);
95 }
96 
97 void *
kmem_zone_alloc(kmem_zone_t * zone,xfs_km_flags_t flags)98 kmem_zone_alloc(kmem_zone_t *zone, xfs_km_flags_t flags)
99 {
100 	int	retries = 0;
101 	gfp_t	lflags = kmem_flags_convert(flags);
102 	void	*ptr;
103 
104 	do {
105 		ptr = kmem_cache_alloc(zone, lflags);
106 		if (ptr || (flags & (KM_MAYFAIL|KM_NOSLEEP)))
107 			return ptr;
108 		if (!(++retries % 100))
109 			xfs_err(NULL,
110 		"%s(%u) possible memory allocation deadlock in %s (mode:0x%x)",
111 				current->comm, current->pid,
112 				__func__, lflags);
113 		congestion_wait(BLK_RW_ASYNC, HZ/50);
114 	} while (1);
115 }
116