]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/fs/file.c | |
3 | * | |
4 | * Copyright (C) 1998-1999, Stephen Tweedie and Bill Hawes | |
5 | * | |
6 | * Manage the dynamic fd arrays in the process files_struct. | |
7 | */ | |
8 | ||
630d9c47 | 9 | #include <linux/export.h> |
1da177e4 LT |
10 | #include <linux/fs.h> |
11 | #include <linux/mm.h> | |
6d4831c2 | 12 | #include <linux/mmzone.h> |
1da177e4 | 13 | #include <linux/time.h> |
d43c36dc | 14 | #include <linux/sched.h> |
1da177e4 LT |
15 | #include <linux/slab.h> |
16 | #include <linux/vmalloc.h> | |
17 | #include <linux/file.h> | |
9f3acc31 | 18 | #include <linux/fdtable.h> |
1da177e4 | 19 | #include <linux/bitops.h> |
ab2af1f5 DS |
20 | #include <linux/interrupt.h> |
21 | #include <linux/spinlock.h> | |
22 | #include <linux/rcupdate.h> | |
23 | #include <linux/workqueue.h> | |
24 | ||
25 | struct fdtable_defer { | |
26 | spinlock_t lock; | |
27 | struct work_struct wq; | |
ab2af1f5 DS |
28 | struct fdtable *next; |
29 | }; | |
30 | ||
9cfe015a | 31 | int sysctl_nr_open __read_mostly = 1024*1024; |
eceea0b3 AV |
32 | int sysctl_nr_open_min = BITS_PER_LONG; |
33 | int sysctl_nr_open_max = 1024 * 1024; /* raised later */ | |
9cfe015a | 34 | |
ab2af1f5 DS |
35 | /* |
36 | * We use this list to defer free fdtables that have vmalloced | |
37 | * sets/arrays. By keeping a per-cpu list, we avoid having to embed | |
38 | * the work_struct in fdtable itself which avoids a 64 byte (i386) increase in | |
39 | * this per-task structure. | |
40 | */ | |
41 | static DEFINE_PER_CPU(struct fdtable_defer, fdtable_defer_list); | |
1da177e4 | 42 | |
1fd36adc | 43 | static void *alloc_fdmem(size_t size) |
1da177e4 | 44 | { |
6d4831c2 AM |
45 | /* |
46 | * Very large allocations can stress page reclaim, so fall back to | |
47 | * vmalloc() if the allocation size will be considered "large" by the VM. | |
48 | */ | |
49 | if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER)) { | |
50 | void *data = kmalloc(size, GFP_KERNEL|__GFP_NOWARN); | |
51 | if (data != NULL) | |
52 | return data; | |
53 | } | |
a892e2d7 | 54 | return vmalloc(size); |
1da177e4 LT |
55 | } |
56 | ||
a892e2d7 | 57 | static void free_fdmem(void *ptr) |
1da177e4 | 58 | { |
a892e2d7 | 59 | is_vmalloc_addr(ptr) ? vfree(ptr) : kfree(ptr); |
1da177e4 LT |
60 | } |
61 | ||
a892e2d7 | 62 | static void __free_fdtable(struct fdtable *fdt) |
1da177e4 | 63 | { |
a892e2d7 CG |
64 | free_fdmem(fdt->fd); |
65 | free_fdmem(fdt->open_fds); | |
66 | kfree(fdt); | |
ab2af1f5 | 67 | } |
1da177e4 | 68 | |
65f27f38 | 69 | static void free_fdtable_work(struct work_struct *work) |
ab2af1f5 | 70 | { |
65f27f38 DH |
71 | struct fdtable_defer *f = |
72 | container_of(work, struct fdtable_defer, wq); | |
ab2af1f5 | 73 | struct fdtable *fdt; |
1da177e4 | 74 | |
ab2af1f5 DS |
75 | spin_lock_bh(&f->lock); |
76 | fdt = f->next; | |
77 | f->next = NULL; | |
78 | spin_unlock_bh(&f->lock); | |
79 | while(fdt) { | |
80 | struct fdtable *next = fdt->next; | |
a892e2d7 CG |
81 | |
82 | __free_fdtable(fdt); | |
ab2af1f5 DS |
83 | fdt = next; |
84 | } | |
85 | } | |
1da177e4 | 86 | |
7cf4dc3c | 87 | static void free_fdtable_rcu(struct rcu_head *rcu) |
ab2af1f5 DS |
88 | { |
89 | struct fdtable *fdt = container_of(rcu, struct fdtable, rcu); | |
ab2af1f5 | 90 | struct fdtable_defer *fddef; |
1da177e4 | 91 | |
ab2af1f5 | 92 | BUG_ON(!fdt); |
ab2af1f5 | 93 | |
4fd45812 | 94 | if (fdt->max_fds <= NR_OPEN_DEFAULT) { |
ab2af1f5 | 95 | /* |
4fd45812 VL |
96 | * This fdtable is embedded in the files structure and that |
97 | * structure itself is getting destroyed. | |
ab2af1f5 | 98 | */ |
4fd45812 VL |
99 | kmem_cache_free(files_cachep, |
100 | container_of(fdt, struct files_struct, fdtab)); | |
ab2af1f5 DS |
101 | return; |
102 | } | |
a892e2d7 | 103 | if (!is_vmalloc_addr(fdt->fd) && !is_vmalloc_addr(fdt->open_fds)) { |
ab2af1f5 | 104 | kfree(fdt->fd); |
5466b456 | 105 | kfree(fdt->open_fds); |
ab2af1f5 | 106 | kfree(fdt); |
1da177e4 | 107 | } else { |
ab2af1f5 DS |
108 | fddef = &get_cpu_var(fdtable_defer_list); |
109 | spin_lock(&fddef->lock); | |
110 | fdt->next = fddef->next; | |
111 | fddef->next = fdt; | |
593be07a TH |
112 | /* vmallocs are handled from the workqueue context */ |
113 | schedule_work(&fddef->wq); | |
ab2af1f5 DS |
114 | spin_unlock(&fddef->lock); |
115 | put_cpu_var(fdtable_defer_list); | |
1da177e4 | 116 | } |
ab2af1f5 DS |
117 | } |
118 | ||
7cf4dc3c AV |
119 | static inline void free_fdtable(struct fdtable *fdt) |
120 | { | |
121 | call_rcu(&fdt->rcu, free_fdtable_rcu); | |
122 | } | |
123 | ||
ab2af1f5 DS |
124 | /* |
125 | * Expand the fdset in the files_struct. Called with the files spinlock | |
126 | * held for write. | |
127 | */ | |
5466b456 | 128 | static void copy_fdtable(struct fdtable *nfdt, struct fdtable *ofdt) |
ab2af1f5 | 129 | { |
5466b456 | 130 | unsigned int cpy, set; |
ab2af1f5 | 131 | |
5466b456 | 132 | BUG_ON(nfdt->max_fds < ofdt->max_fds); |
5466b456 VL |
133 | |
134 | cpy = ofdt->max_fds * sizeof(struct file *); | |
135 | set = (nfdt->max_fds - ofdt->max_fds) * sizeof(struct file *); | |
136 | memcpy(nfdt->fd, ofdt->fd, cpy); | |
137 | memset((char *)(nfdt->fd) + cpy, 0, set); | |
138 | ||
139 | cpy = ofdt->max_fds / BITS_PER_BYTE; | |
140 | set = (nfdt->max_fds - ofdt->max_fds) / BITS_PER_BYTE; | |
141 | memcpy(nfdt->open_fds, ofdt->open_fds, cpy); | |
142 | memset((char *)(nfdt->open_fds) + cpy, 0, set); | |
143 | memcpy(nfdt->close_on_exec, ofdt->close_on_exec, cpy); | |
144 | memset((char *)(nfdt->close_on_exec) + cpy, 0, set); | |
1da177e4 LT |
145 | } |
146 | ||
5466b456 | 147 | static struct fdtable * alloc_fdtable(unsigned int nr) |
1da177e4 | 148 | { |
5466b456 | 149 | struct fdtable *fdt; |
1fd36adc | 150 | void *data; |
1da177e4 | 151 | |
ab2af1f5 | 152 | /* |
5466b456 VL |
153 | * Figure out how many fds we actually want to support in this fdtable. |
154 | * Allocation steps are keyed to the size of the fdarray, since it | |
155 | * grows far faster than any of the other dynamic data. We try to fit | |
156 | * the fdarray into comfortable page-tuned chunks: starting at 1024B | |
157 | * and growing in powers of two from there on. | |
ab2af1f5 | 158 | */ |
5466b456 VL |
159 | nr /= (1024 / sizeof(struct file *)); |
160 | nr = roundup_pow_of_two(nr + 1); | |
161 | nr *= (1024 / sizeof(struct file *)); | |
5c598b34 AV |
162 | /* |
163 | * Note that this can drive nr *below* what we had passed if sysctl_nr_open | |
164 | * had been set lower between the check in expand_files() and here. Deal | |
165 | * with that in caller, it's cheaper that way. | |
166 | * | |
167 | * We make sure that nr remains a multiple of BITS_PER_LONG - otherwise | |
168 | * bitmaps handling below becomes unpleasant, to put it mildly... | |
169 | */ | |
170 | if (unlikely(nr > sysctl_nr_open)) | |
171 | nr = ((sysctl_nr_open - 1) | (BITS_PER_LONG - 1)) + 1; | |
bbea9f69 | 172 | |
5466b456 VL |
173 | fdt = kmalloc(sizeof(struct fdtable), GFP_KERNEL); |
174 | if (!fdt) | |
bbea9f69 | 175 | goto out; |
5466b456 VL |
176 | fdt->max_fds = nr; |
177 | data = alloc_fdmem(nr * sizeof(struct file *)); | |
178 | if (!data) | |
179 | goto out_fdt; | |
1fd36adc DH |
180 | fdt->fd = data; |
181 | ||
182 | data = alloc_fdmem(max_t(size_t, | |
5466b456 VL |
183 | 2 * nr / BITS_PER_BYTE, L1_CACHE_BYTES)); |
184 | if (!data) | |
185 | goto out_arr; | |
1fd36adc | 186 | fdt->open_fds = data; |
5466b456 | 187 | data += nr / BITS_PER_BYTE; |
1fd36adc | 188 | fdt->close_on_exec = data; |
5466b456 VL |
189 | fdt->next = NULL; |
190 | ||
ab2af1f5 | 191 | return fdt; |
5466b456 VL |
192 | |
193 | out_arr: | |
a892e2d7 | 194 | free_fdmem(fdt->fd); |
5466b456 | 195 | out_fdt: |
ab2af1f5 | 196 | kfree(fdt); |
5466b456 | 197 | out: |
ab2af1f5 DS |
198 | return NULL; |
199 | } | |
1da177e4 | 200 | |
ab2af1f5 | 201 | /* |
74d392aa VL |
202 | * Expand the file descriptor table. |
203 | * This function will allocate a new fdtable and both fd array and fdset, of | |
204 | * the given size. | |
205 | * Return <0 error code on error; 1 on successful completion. | |
206 | * The files->file_lock should be held on entry, and will be held on exit. | |
ab2af1f5 DS |
207 | */ |
208 | static int expand_fdtable(struct files_struct *files, int nr) | |
209 | __releases(files->file_lock) | |
210 | __acquires(files->file_lock) | |
211 | { | |
74d392aa | 212 | struct fdtable *new_fdt, *cur_fdt; |
ab2af1f5 DS |
213 | |
214 | spin_unlock(&files->file_lock); | |
74d392aa | 215 | new_fdt = alloc_fdtable(nr); |
ab2af1f5 | 216 | spin_lock(&files->file_lock); |
74d392aa VL |
217 | if (!new_fdt) |
218 | return -ENOMEM; | |
5c598b34 AV |
219 | /* |
220 | * extremely unlikely race - sysctl_nr_open decreased between the check in | |
221 | * caller and alloc_fdtable(). Cheaper to catch it here... | |
222 | */ | |
223 | if (unlikely(new_fdt->max_fds <= nr)) { | |
a892e2d7 | 224 | __free_fdtable(new_fdt); |
5c598b34 AV |
225 | return -EMFILE; |
226 | } | |
ab2af1f5 | 227 | /* |
74d392aa VL |
228 | * Check again since another task may have expanded the fd table while |
229 | * we dropped the lock | |
ab2af1f5 | 230 | */ |
74d392aa | 231 | cur_fdt = files_fdtable(files); |
bbea9f69 | 232 | if (nr >= cur_fdt->max_fds) { |
74d392aa VL |
233 | /* Continue as planned */ |
234 | copy_fdtable(new_fdt, cur_fdt); | |
235 | rcu_assign_pointer(files->fdt, new_fdt); | |
4fd45812 | 236 | if (cur_fdt->max_fds > NR_OPEN_DEFAULT) |
01b2d93c | 237 | free_fdtable(cur_fdt); |
ab2af1f5 | 238 | } else { |
74d392aa | 239 | /* Somebody else expanded, so undo our attempt */ |
a892e2d7 | 240 | __free_fdtable(new_fdt); |
ab2af1f5 | 241 | } |
74d392aa | 242 | return 1; |
1da177e4 LT |
243 | } |
244 | ||
245 | /* | |
246 | * Expand files. | |
74d392aa VL |
247 | * This function will expand the file structures, if the requested size exceeds |
248 | * the current capacity and there is room for expansion. | |
249 | * Return <0 error code on error; 0 when nothing done; 1 when files were | |
250 | * expanded and execution may have blocked. | |
251 | * The files->file_lock should be held on entry, and will be held on exit. | |
1da177e4 LT |
252 | */ |
253 | int expand_files(struct files_struct *files, int nr) | |
254 | { | |
badf1662 | 255 | struct fdtable *fdt; |
1da177e4 | 256 | |
badf1662 | 257 | fdt = files_fdtable(files); |
4e1e018e | 258 | |
74d392aa | 259 | /* Do we need to expand? */ |
bbea9f69 | 260 | if (nr < fdt->max_fds) |
74d392aa | 261 | return 0; |
4e1e018e | 262 | |
74d392aa | 263 | /* Can we expand? */ |
9cfe015a | 264 | if (nr >= sysctl_nr_open) |
74d392aa VL |
265 | return -EMFILE; |
266 | ||
267 | /* All good, so we try */ | |
268 | return expand_fdtable(files, nr); | |
1da177e4 | 269 | } |
ab2af1f5 | 270 | |
02afc626 AV |
271 | static int count_open_files(struct fdtable *fdt) |
272 | { | |
273 | int size = fdt->max_fds; | |
274 | int i; | |
275 | ||
276 | /* Find the last open fd */ | |
1fd36adc DH |
277 | for (i = size / BITS_PER_LONG; i > 0; ) { |
278 | if (fdt->open_fds[--i]) | |
02afc626 AV |
279 | break; |
280 | } | |
1fd36adc | 281 | i = (i + 1) * BITS_PER_LONG; |
02afc626 AV |
282 | return i; |
283 | } | |
284 | ||
02afc626 AV |
285 | /* |
286 | * Allocate a new files structure and copy contents from the | |
287 | * passed in files structure. | |
288 | * errorp will be valid only when the returned files_struct is NULL. | |
289 | */ | |
290 | struct files_struct *dup_fd(struct files_struct *oldf, int *errorp) | |
291 | { | |
292 | struct files_struct *newf; | |
293 | struct file **old_fds, **new_fds; | |
294 | int open_files, size, i; | |
295 | struct fdtable *old_fdt, *new_fdt; | |
296 | ||
297 | *errorp = -ENOMEM; | |
afbec7ff | 298 | newf = kmem_cache_alloc(files_cachep, GFP_KERNEL); |
02afc626 AV |
299 | if (!newf) |
300 | goto out; | |
301 | ||
afbec7ff AV |
302 | atomic_set(&newf->count, 1); |
303 | ||
304 | spin_lock_init(&newf->file_lock); | |
305 | newf->next_fd = 0; | |
306 | new_fdt = &newf->fdtab; | |
307 | new_fdt->max_fds = NR_OPEN_DEFAULT; | |
1fd36adc DH |
308 | new_fdt->close_on_exec = newf->close_on_exec_init; |
309 | new_fdt->open_fds = newf->open_fds_init; | |
afbec7ff | 310 | new_fdt->fd = &newf->fd_array[0]; |
afbec7ff AV |
311 | new_fdt->next = NULL; |
312 | ||
02afc626 AV |
313 | spin_lock(&oldf->file_lock); |
314 | old_fdt = files_fdtable(oldf); | |
02afc626 AV |
315 | open_files = count_open_files(old_fdt); |
316 | ||
317 | /* | |
318 | * Check whether we need to allocate a larger fd array and fd set. | |
02afc626 | 319 | */ |
adbecb12 | 320 | while (unlikely(open_files > new_fdt->max_fds)) { |
02afc626 | 321 | spin_unlock(&oldf->file_lock); |
9dec3c4d | 322 | |
a892e2d7 CG |
323 | if (new_fdt != &newf->fdtab) |
324 | __free_fdtable(new_fdt); | |
adbecb12 | 325 | |
9dec3c4d AV |
326 | new_fdt = alloc_fdtable(open_files - 1); |
327 | if (!new_fdt) { | |
328 | *errorp = -ENOMEM; | |
329 | goto out_release; | |
330 | } | |
331 | ||
332 | /* beyond sysctl_nr_open; nothing to do */ | |
333 | if (unlikely(new_fdt->max_fds < open_files)) { | |
a892e2d7 | 334 | __free_fdtable(new_fdt); |
9dec3c4d | 335 | *errorp = -EMFILE; |
02afc626 | 336 | goto out_release; |
9dec3c4d | 337 | } |
9dec3c4d | 338 | |
02afc626 AV |
339 | /* |
340 | * Reacquire the oldf lock and a pointer to its fd table | |
341 | * who knows it may have a new bigger fd table. We need | |
342 | * the latest pointer. | |
343 | */ | |
344 | spin_lock(&oldf->file_lock); | |
345 | old_fdt = files_fdtable(oldf); | |
adbecb12 | 346 | open_files = count_open_files(old_fdt); |
02afc626 AV |
347 | } |
348 | ||
349 | old_fds = old_fdt->fd; | |
350 | new_fds = new_fdt->fd; | |
351 | ||
1fd36adc DH |
352 | memcpy(new_fdt->open_fds, old_fdt->open_fds, open_files / 8); |
353 | memcpy(new_fdt->close_on_exec, old_fdt->close_on_exec, open_files / 8); | |
02afc626 AV |
354 | |
355 | for (i = open_files; i != 0; i--) { | |
356 | struct file *f = *old_fds++; | |
357 | if (f) { | |
358 | get_file(f); | |
359 | } else { | |
360 | /* | |
361 | * The fd may be claimed in the fd bitmap but not yet | |
362 | * instantiated in the files array if a sibling thread | |
363 | * is partway through open(). So make sure that this | |
364 | * fd is available to the new process. | |
365 | */ | |
1dce27c5 | 366 | __clear_open_fd(open_files - i, new_fdt); |
02afc626 AV |
367 | } |
368 | rcu_assign_pointer(*new_fds++, f); | |
369 | } | |
370 | spin_unlock(&oldf->file_lock); | |
371 | ||
372 | /* compute the remainder to be cleared */ | |
373 | size = (new_fdt->max_fds - open_files) * sizeof(struct file *); | |
374 | ||
375 | /* This is long word aligned thus could use a optimized version */ | |
376 | memset(new_fds, 0, size); | |
377 | ||
378 | if (new_fdt->max_fds > open_files) { | |
1fd36adc DH |
379 | int left = (new_fdt->max_fds - open_files) / 8; |
380 | int start = open_files / BITS_PER_LONG; | |
02afc626 | 381 | |
1fd36adc DH |
382 | memset(&new_fdt->open_fds[start], 0, left); |
383 | memset(&new_fdt->close_on_exec[start], 0, left); | |
02afc626 AV |
384 | } |
385 | ||
afbec7ff AV |
386 | rcu_assign_pointer(newf->fdt, new_fdt); |
387 | ||
02afc626 AV |
388 | return newf; |
389 | ||
390 | out_release: | |
391 | kmem_cache_free(files_cachep, newf); | |
392 | out: | |
393 | return NULL; | |
394 | } | |
395 | ||
7cf4dc3c AV |
396 | static void close_files(struct files_struct * files) |
397 | { | |
398 | int i, j; | |
399 | struct fdtable *fdt; | |
400 | ||
401 | j = 0; | |
402 | ||
403 | /* | |
404 | * It is safe to dereference the fd table without RCU or | |
405 | * ->file_lock because this is the last reference to the | |
406 | * files structure. But use RCU to shut RCU-lockdep up. | |
407 | */ | |
408 | rcu_read_lock(); | |
409 | fdt = files_fdtable(files); | |
410 | rcu_read_unlock(); | |
411 | for (;;) { | |
412 | unsigned long set; | |
413 | i = j * BITS_PER_LONG; | |
414 | if (i >= fdt->max_fds) | |
415 | break; | |
416 | set = fdt->open_fds[j++]; | |
417 | while (set) { | |
418 | if (set & 1) { | |
419 | struct file * file = xchg(&fdt->fd[i], NULL); | |
420 | if (file) { | |
421 | filp_close(file, files); | |
422 | cond_resched(); | |
423 | } | |
424 | } | |
425 | i++; | |
426 | set >>= 1; | |
427 | } | |
428 | } | |
429 | } | |
430 | ||
431 | struct files_struct *get_files_struct(struct task_struct *task) | |
432 | { | |
433 | struct files_struct *files; | |
434 | ||
435 | task_lock(task); | |
436 | files = task->files; | |
437 | if (files) | |
438 | atomic_inc(&files->count); | |
439 | task_unlock(task); | |
440 | ||
441 | return files; | |
442 | } | |
443 | ||
444 | void put_files_struct(struct files_struct *files) | |
445 | { | |
446 | struct fdtable *fdt; | |
447 | ||
448 | if (atomic_dec_and_test(&files->count)) { | |
449 | close_files(files); | |
b9e02af0 | 450 | /* not really needed, since nobody can see us */ |
7cf4dc3c AV |
451 | rcu_read_lock(); |
452 | fdt = files_fdtable(files); | |
7cf4dc3c | 453 | rcu_read_unlock(); |
b9e02af0 AV |
454 | /* free the arrays if they are not embedded */ |
455 | if (fdt != &files->fdtab) | |
456 | __free_fdtable(fdt); | |
457 | kmem_cache_free(files_cachep, files); | |
7cf4dc3c AV |
458 | } |
459 | } | |
460 | ||
461 | void reset_files_struct(struct files_struct *files) | |
462 | { | |
463 | struct task_struct *tsk = current; | |
464 | struct files_struct *old; | |
465 | ||
466 | old = tsk->files; | |
467 | task_lock(tsk); | |
468 | tsk->files = files; | |
469 | task_unlock(tsk); | |
470 | put_files_struct(old); | |
471 | } | |
472 | ||
473 | void exit_files(struct task_struct *tsk) | |
474 | { | |
475 | struct files_struct * files = tsk->files; | |
476 | ||
477 | if (files) { | |
478 | task_lock(tsk); | |
479 | tsk->files = NULL; | |
480 | task_unlock(tsk); | |
481 | put_files_struct(files); | |
482 | } | |
483 | } | |
484 | ||
ab2af1f5 DS |
485 | static void __devinit fdtable_defer_list_init(int cpu) |
486 | { | |
487 | struct fdtable_defer *fddef = &per_cpu(fdtable_defer_list, cpu); | |
488 | spin_lock_init(&fddef->lock); | |
65f27f38 | 489 | INIT_WORK(&fddef->wq, free_fdtable_work); |
ab2af1f5 DS |
490 | fddef->next = NULL; |
491 | } | |
492 | ||
493 | void __init files_defer_init(void) | |
494 | { | |
495 | int i; | |
0a945022 | 496 | for_each_possible_cpu(i) |
ab2af1f5 | 497 | fdtable_defer_list_init(i); |
eceea0b3 AV |
498 | sysctl_nr_open_max = min((size_t)INT_MAX, ~(size_t)0/sizeof(void *)) & |
499 | -BITS_PER_LONG; | |
ab2af1f5 | 500 | } |
f52111b1 AV |
501 | |
502 | struct files_struct init_files = { | |
503 | .count = ATOMIC_INIT(1), | |
504 | .fdt = &init_files.fdtab, | |
505 | .fdtab = { | |
506 | .max_fds = NR_OPEN_DEFAULT, | |
507 | .fd = &init_files.fd_array[0], | |
1fd36adc DH |
508 | .close_on_exec = init_files.close_on_exec_init, |
509 | .open_fds = init_files.open_fds_init, | |
f52111b1 AV |
510 | }, |
511 | .file_lock = __SPIN_LOCK_UNLOCKED(init_task.file_lock), | |
512 | }; | |
1027abe8 AV |
513 | |
514 | /* | |
515 | * allocate a file descriptor, mark it busy. | |
516 | */ | |
dcfadfa4 AV |
517 | int __alloc_fd(struct files_struct *files, |
518 | unsigned start, unsigned end, unsigned flags) | |
1027abe8 | 519 | { |
1027abe8 AV |
520 | unsigned int fd; |
521 | int error; | |
522 | struct fdtable *fdt; | |
523 | ||
524 | spin_lock(&files->file_lock); | |
525 | repeat: | |
526 | fdt = files_fdtable(files); | |
527 | fd = start; | |
528 | if (fd < files->next_fd) | |
529 | fd = files->next_fd; | |
530 | ||
531 | if (fd < fdt->max_fds) | |
1fd36adc | 532 | fd = find_next_zero_bit(fdt->open_fds, fdt->max_fds, fd); |
1027abe8 | 533 | |
f33ff992 AV |
534 | /* |
535 | * N.B. For clone tasks sharing a files structure, this test | |
536 | * will limit the total number of files that can be opened. | |
537 | */ | |
538 | error = -EMFILE; | |
539 | if (fd >= end) | |
540 | goto out; | |
541 | ||
1027abe8 AV |
542 | error = expand_files(files, fd); |
543 | if (error < 0) | |
544 | goto out; | |
545 | ||
546 | /* | |
547 | * If we needed to expand the fs array we | |
548 | * might have blocked - try again. | |
549 | */ | |
550 | if (error) | |
551 | goto repeat; | |
552 | ||
553 | if (start <= files->next_fd) | |
554 | files->next_fd = fd + 1; | |
555 | ||
1dce27c5 | 556 | __set_open_fd(fd, fdt); |
1027abe8 | 557 | if (flags & O_CLOEXEC) |
1dce27c5 | 558 | __set_close_on_exec(fd, fdt); |
1027abe8 | 559 | else |
1dce27c5 | 560 | __clear_close_on_exec(fd, fdt); |
1027abe8 AV |
561 | error = fd; |
562 | #if 1 | |
563 | /* Sanity check */ | |
7dc52157 | 564 | if (rcu_dereference_raw(fdt->fd[fd]) != NULL) { |
1027abe8 AV |
565 | printk(KERN_WARNING "alloc_fd: slot %d not NULL!\n", fd); |
566 | rcu_assign_pointer(fdt->fd[fd], NULL); | |
567 | } | |
568 | #endif | |
569 | ||
570 | out: | |
571 | spin_unlock(&files->file_lock); | |
572 | return error; | |
573 | } | |
574 | ||
dcfadfa4 AV |
575 | int alloc_fd(unsigned start, unsigned flags) |
576 | { | |
577 | return __alloc_fd(current->files, start, rlimit(RLIMIT_NOFILE), flags); | |
578 | } | |
579 | ||
1a7bd226 | 580 | int get_unused_fd_flags(unsigned flags) |
1027abe8 | 581 | { |
dcfadfa4 | 582 | return __alloc_fd(current->files, 0, rlimit(RLIMIT_NOFILE), flags); |
1027abe8 | 583 | } |
1a7bd226 | 584 | EXPORT_SYMBOL(get_unused_fd_flags); |