file.c 8.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 *  linux/fs/file.c
 *
 *  Copyright (C) 1998-1999, Stephen Tweedie and Bill Hawes
 *
 *  Manage the dynamic fd arrays in the process files_struct.
 */

#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/time.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/file.h>
#include <linux/bitops.h>
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/rcupdate.h>
#include <linux/workqueue.h>

struct fdtable_defer {
	spinlock_t lock;
	struct work_struct wq;
	struct timer_list timer;
	struct fdtable *next;
};

/*
 * We use this list to defer free fdtables that have vmalloced
 * sets/arrays. By keeping a per-cpu list, we avoid having to embed
 * the work_struct in fdtable itself which avoids a 64 byte (i386) increase in
 * this per-task structure.
 */
static DEFINE_PER_CPU(struct fdtable_defer, fdtable_defer_list);
L
Linus Torvalds 已提交
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


/*
 * Allocate an fd array, using kmalloc or vmalloc.
 * Note: the array isn't cleared at allocation time.
 */
struct file ** alloc_fd_array(int num)
{
	struct file **new_fds;
	int size = num * sizeof(struct file *);

	if (size <= PAGE_SIZE)
		new_fds = (struct file **) kmalloc(size, GFP_KERNEL);
	else 
		new_fds = (struct file **) vmalloc(size);
	return new_fds;
}

void free_fd_array(struct file **array, int num)
{
	int size = num * sizeof(struct file *);

	if (!array) {
		printk (KERN_ERR "free_fd_array: array = 0 (num = %d)\n", num);
		return;
	}

	if (num <= NR_OPEN_DEFAULT) /* Don't free the embedded fd array! */
		return;
	else if (size <= PAGE_SIZE)
		kfree(array);
	else
		vfree(array);
}

70
static void __free_fdtable(struct fdtable *fdt)
L
Linus Torvalds 已提交
71
{
72 73 74
	free_fdset(fdt->open_fds, fdt->max_fdset);
	free_fdset(fdt->close_on_exec, fdt->max_fdset);
	free_fd_array(fdt->fd, fdt->max_fds);
75 76
	kfree(fdt);
}
L
Linus Torvalds 已提交
77

78 79 80
static void fdtable_timer(unsigned long data)
{
	struct fdtable_defer *fddef = (struct fdtable_defer *)data;
L
Linus Torvalds 已提交
81

82 83 84
	spin_lock(&fddef->lock);
	/*
	 * If someone already emptied the queue return.
L
Linus Torvalds 已提交
85
	 */
86 87 88 89 90 91 92
	if (!fddef->next)
		goto out;
	if (!schedule_work(&fddef->wq))
		mod_timer(&fddef->timer, 5);
out:
	spin_unlock(&fddef->lock);
}
L
Linus Torvalds 已提交
93

94
static void free_fdtable_work(struct work_struct *work)
95
{
96 97
	struct fdtable_defer *f =
		container_of(work, struct fdtable_defer, wq);
98
	struct fdtable *fdt;
L
Linus Torvalds 已提交
99

100 101 102 103 104 105 106 107 108 109
	spin_lock_bh(&f->lock);
	fdt = f->next;
	f->next = NULL;
	spin_unlock_bh(&f->lock);
	while(fdt) {
		struct fdtable *next = fdt->next;
		__free_fdtable(fdt);
		fdt = next;
	}
}
L
Linus Torvalds 已提交
110

111 112 113 114 115
static void free_fdtable_rcu(struct rcu_head *rcu)
{
	struct fdtable *fdt = container_of(rcu, struct fdtable, rcu);
	int fdset_size, fdarray_size;
	struct fdtable_defer *fddef;
L
Linus Torvalds 已提交
116

117 118 119 120 121 122 123 124 125 126 127 128 129
	BUG_ON(!fdt);
	fdset_size = fdt->max_fdset / 8;
	fdarray_size = fdt->max_fds * sizeof(struct file *);

	if (fdt->free_files) {
		/*
		 * The this fdtable was embedded in the files structure
		 * and the files structure itself was getting destroyed.
		 * It is now safe to free the files structure.
		 */
		kmem_cache_free(files_cachep, fdt->free_files);
		return;
	}
130 131
	if (fdt->max_fdset <= EMBEDDED_FD_SET_SIZE &&
		fdt->max_fds <= NR_OPEN_DEFAULT) {
132 133 134 135 136 137 138 139 140 141
		/*
		 * The fdtable was embedded
		 */
		return;
	}
	if (fdset_size <= PAGE_SIZE && fdarray_size <= PAGE_SIZE) {
		kfree(fdt->open_fds);
		kfree(fdt->close_on_exec);
		kfree(fdt->fd);
		kfree(fdt);
L
Linus Torvalds 已提交
142
	} else {
143 144 145 146 147 148 149 150 151 152 153 154 155
		fddef = &get_cpu_var(fdtable_defer_list);
		spin_lock(&fddef->lock);
		fdt->next = fddef->next;
		fddef->next = fdt;
		/*
		 * vmallocs are handled from the workqueue context.
		 * If the per-cpu workqueue is running, then we
		 * defer work scheduling through a timer.
		 */
		if (!schedule_work(&fddef->wq))
			mod_timer(&fddef->timer, 5);
		spin_unlock(&fddef->lock);
		put_cpu_var(fdtable_defer_list);
L
Linus Torvalds 已提交
156
	}
157 158 159 160
}

void free_fdtable(struct fdtable *fdt)
{
161 162 163
	if (fdt->free_files ||
		fdt->max_fdset > EMBEDDED_FD_SET_SIZE ||
		fdt->max_fds > NR_OPEN_DEFAULT)
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205
		call_rcu(&fdt->rcu, free_fdtable_rcu);
}

/*
 * Expand the fdset in the files_struct.  Called with the files spinlock
 * held for write.
 */
static void copy_fdtable(struct fdtable *nfdt, struct fdtable *fdt)
{
	int i;
	int count;

	BUG_ON(nfdt->max_fdset < fdt->max_fdset);
	BUG_ON(nfdt->max_fds < fdt->max_fds);
	/* Copy the existing tables and install the new pointers */

	i = fdt->max_fdset / (sizeof(unsigned long) * 8);
	count = (nfdt->max_fdset - fdt->max_fdset) / 8;

	/*
	 * Don't copy the entire array if the current fdset is
	 * not yet initialised.
	 */
	if (i) {
		memcpy (nfdt->open_fds, fdt->open_fds,
						fdt->max_fdset/8);
		memcpy (nfdt->close_on_exec, fdt->close_on_exec,
						fdt->max_fdset/8);
		memset (&nfdt->open_fds->fds_bits[i], 0, count);
		memset (&nfdt->close_on_exec->fds_bits[i], 0, count);
	}

	/* Don't copy/clear the array if we are creating a new
	   fd array for fork() */
	if (fdt->max_fds) {
		memcpy(nfdt->fd, fdt->fd,
			fdt->max_fds * sizeof(struct file *));
		/* clear the remainder of the array */
		memset(&nfdt->fd[fdt->max_fds], 0,
		       (nfdt->max_fds - fdt->max_fds) *
					sizeof(struct file *));
	}
L
Linus Torvalds 已提交
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
}

/*
 * Allocate an fdset array, using kmalloc or vmalloc.
 * Note: the array isn't cleared at allocation time.
 */
fd_set * alloc_fdset(int num)
{
	fd_set *new_fdset;
	int size = num / 8;

	if (size <= PAGE_SIZE)
		new_fdset = (fd_set *) kmalloc(size, GFP_KERNEL);
	else
		new_fdset = (fd_set *) vmalloc(size);
	return new_fdset;
}

void free_fdset(fd_set *array, int num)
{
226
	if (num <= EMBEDDED_FD_SET_SIZE) /* Don't free an embedded fdset */
L
Linus Torvalds 已提交
227
		return;
228
	else if (num <= 8 * PAGE_SIZE)
L
Linus Torvalds 已提交
229 230 231 232 233
		kfree(array);
	else
		vfree(array);
}

234
static struct fdtable *alloc_fdtable(int nr)
L
Linus Torvalds 已提交
235
{
236 237 238 239
	struct fdtable *fdt = NULL;
	int nfds = 0;
  	fd_set *new_openset = NULL, *new_execset = NULL;
	struct file **new_fds;
L
Linus Torvalds 已提交
240

241
	fdt = kzalloc(sizeof(*fdt), GFP_KERNEL);
242 243
	if (!fdt)
  		goto out;
L
Linus Torvalds 已提交
244

245
	nfds = max_t(int, 8 * L1_CACHE_BYTES, roundup_pow_of_two(nr + 1));
246 247
	if (nfds > NR_OPEN)
		nfds = NR_OPEN;
L
Linus Torvalds 已提交
248

249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
  	new_openset = alloc_fdset(nfds);
  	new_execset = alloc_fdset(nfds);
  	if (!new_openset || !new_execset)
  		goto out;
	fdt->open_fds = new_openset;
	fdt->close_on_exec = new_execset;
	fdt->max_fdset = nfds;

	nfds = NR_OPEN_DEFAULT;
	/*
	 * Expand to the max in easy steps, and keep expanding it until
	 * we have enough for the requested fd array size.
	 */
	do {
#if NR_OPEN_DEFAULT < 256
		if (nfds < 256)
			nfds = 256;
		else
#endif
		if (nfds < (PAGE_SIZE / sizeof(struct file *)))
			nfds = PAGE_SIZE / sizeof(struct file *);
		else {
			nfds = nfds * 2;
			if (nfds > NR_OPEN)
				nfds = NR_OPEN;
  		}
	} while (nfds <= nr);
	new_fds = alloc_fd_array(nfds);
	if (!new_fds)
K
Kirill Korotaev 已提交
278
		goto out2;
279 280 281 282
	fdt->fd = new_fds;
	fdt->max_fds = nfds;
	fdt->free_files = NULL;
	return fdt;
K
Kirill Korotaev 已提交
283 284
out2:
	nfds = fdt->max_fdset;
285
out:
A
Andrew Morton 已提交
286 287
	free_fdset(new_openset, nfds);
	free_fdset(new_execset, nfds);
288 289 290
	kfree(fdt);
	return NULL;
}
L
Linus Torvalds 已提交
291

292
/*
293 294 295 296 297
 * Expand the file descriptor table.
 * This function will allocate a new fdtable and both fd array and fdset, of
 * the given size.
 * Return <0 error code on error; 1 on successful completion.
 * The files->file_lock should be held on entry, and will be held on exit.
298 299 300 301 302
 */
static int expand_fdtable(struct files_struct *files, int nr)
	__releases(files->file_lock)
	__acquires(files->file_lock)
{
303
	struct fdtable *new_fdt, *cur_fdt;
304 305

	spin_unlock(&files->file_lock);
306
	new_fdt = alloc_fdtable(nr);
307
	spin_lock(&files->file_lock);
308 309
	if (!new_fdt)
		return -ENOMEM;
310
	/*
311 312
	 * Check again since another task may have expanded the fd table while
	 * we dropped the lock
313
	 */
314 315 316 317 318 319
	cur_fdt = files_fdtable(files);
	if (nr >= cur_fdt->max_fds || nr >= cur_fdt->max_fdset) {
		/* Continue as planned */
		copy_fdtable(new_fdt, cur_fdt);
		rcu_assign_pointer(files->fdt, new_fdt);
		free_fdtable(cur_fdt);
320
	} else {
321 322
		/* Somebody else expanded, so undo our attempt */
		__free_fdtable(new_fdt);
323
	}
324
	return 1;
L
Linus Torvalds 已提交
325 326 327 328
}

/*
 * Expand files.
329 330 331 332 333
 * This function will expand the file structures, if the requested size exceeds
 * the current capacity and there is room for expansion.
 * Return <0 error code on error; 0 when nothing done; 1 when files were
 * expanded and execution may have blocked.
 * The files->file_lock should be held on entry, and will be held on exit.
L
Linus Torvalds 已提交
334 335 336
 */
int expand_files(struct files_struct *files, int nr)
{
337
	struct fdtable *fdt;
L
Linus Torvalds 已提交
338

339
	fdt = files_fdtable(files);
340 341 342 343 344 345 346 347 348 349
	/* Do we need to expand? */
	if (nr < fdt->max_fdset && nr < fdt->max_fds)
		return 0;
	/* Can we expand? */
	if (fdt->max_fdset >= NR_OPEN || fdt->max_fds >= NR_OPEN ||
	    nr >= NR_OPEN)
		return -EMFILE;

	/* All good, so we try */
	return expand_fdtable(files, nr);
L
Linus Torvalds 已提交
350
}
351 352 353 354 355

static void __devinit fdtable_defer_list_init(int cpu)
{
	struct fdtable_defer *fddef = &per_cpu(fdtable_defer_list, cpu);
	spin_lock_init(&fddef->lock);
356
	INIT_WORK(&fddef->wq, free_fdtable_work);
357 358 359 360 361 362 363 364 365
	init_timer(&fddef->timer);
	fddef->timer.data = (unsigned long)fddef;
	fddef->timer.function = fdtable_timer;
	fddef->next = NULL;
}

void __init files_defer_init(void)
{
	int i;
366
	for_each_possible_cpu(i)
367 368
		fdtable_defer_list_init(i);
}