]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/file.c
4 * Copyright (C) 1998-1999, Stephen Tweedie and Bill Hawes
6 * Manage the dynamic fd arrays in the process files_struct.
11 #include <linux/time.h>
12 #include <linux/slab.h>
13 #include <linux/vmalloc.h>
14 #include <linux/file.h>
15 #include <linux/bitops.h>
16 #include <linux/interrupt.h>
17 #include <linux/spinlock.h>
18 #include <linux/rcupdate.h>
19 #include <linux/workqueue.h>
21 struct fdtable_defer
{
23 struct work_struct wq
;
24 struct timer_list timer
;
29 * We use this list to defer free fdtables that have vmalloced
30 * sets/arrays. By keeping a per-cpu list, we avoid having to embed
31 * the work_struct in fdtable itself which avoids a 64 byte (i386) increase in
32 * this per-task structure.
34 static DEFINE_PER_CPU(struct fdtable_defer
, fdtable_defer_list
);
38 * Allocate an fd array, using kmalloc or vmalloc.
39 * Note: the array isn't cleared at allocation time.
41 struct file
** alloc_fd_array(int num
)
43 struct file
**new_fds
;
44 int size
= num
* sizeof(struct file
*);
46 if (size
<= PAGE_SIZE
)
47 new_fds
= (struct file
**) kmalloc(size
, GFP_KERNEL
);
49 new_fds
= (struct file
**) vmalloc(size
);
53 void free_fd_array(struct file
**array
, int num
)
55 int size
= num
* sizeof(struct file
*);
58 printk (KERN_ERR
"free_fd_array: array = 0 (num = %d)\n", num
);
62 if (num
<= NR_OPEN_DEFAULT
) /* Don't free the embedded fd array! */
64 else if (size
<= PAGE_SIZE
)
70 static void __free_fdtable(struct fdtable
*fdt
)
72 int fdset_size
, fdarray_size
;
74 fdset_size
= fdt
->max_fdset
/ 8;
75 fdarray_size
= fdt
->max_fds
* sizeof(struct file
*);
76 free_fdset(fdt
->open_fds
, fdset_size
);
77 free_fdset(fdt
->close_on_exec
, fdset_size
);
78 free_fd_array(fdt
->fd
, fdarray_size
);
82 static void fdtable_timer(unsigned long data
)
84 struct fdtable_defer
*fddef
= (struct fdtable_defer
*)data
;
86 spin_lock(&fddef
->lock
);
88 * If someone already emptied the queue return.
92 if (!schedule_work(&fddef
->wq
))
93 mod_timer(&fddef
->timer
, 5);
95 spin_unlock(&fddef
->lock
);
98 static void free_fdtable_work(struct fdtable_defer
*f
)
102 spin_lock_bh(&f
->lock
);
105 spin_unlock_bh(&f
->lock
);
107 struct fdtable
*next
= fdt
->next
;
113 static void free_fdtable_rcu(struct rcu_head
*rcu
)
115 struct fdtable
*fdt
= container_of(rcu
, struct fdtable
, rcu
);
116 int fdset_size
, fdarray_size
;
117 struct fdtable_defer
*fddef
;
120 fdset_size
= fdt
->max_fdset
/ 8;
121 fdarray_size
= fdt
->max_fds
* sizeof(struct file
*);
123 if (fdt
->free_files
) {
125 * The this fdtable was embedded in the files structure
126 * and the files structure itself was getting destroyed.
127 * It is now safe to free the files structure.
129 kmem_cache_free(files_cachep
, fdt
->free_files
);
132 if (fdt
->max_fdset
<= __FD_SETSIZE
&& fdt
->max_fds
<= NR_OPEN_DEFAULT
) {
134 * The fdtable was embedded
138 if (fdset_size
<= PAGE_SIZE
&& fdarray_size
<= PAGE_SIZE
) {
139 kfree(fdt
->open_fds
);
140 kfree(fdt
->close_on_exec
);
144 fddef
= &get_cpu_var(fdtable_defer_list
);
145 spin_lock(&fddef
->lock
);
146 fdt
->next
= fddef
->next
;
149 * vmallocs are handled from the workqueue context.
150 * If the per-cpu workqueue is running, then we
151 * defer work scheduling through a timer.
153 if (!schedule_work(&fddef
->wq
))
154 mod_timer(&fddef
->timer
, 5);
155 spin_unlock(&fddef
->lock
);
156 put_cpu_var(fdtable_defer_list
);
160 void free_fdtable(struct fdtable
*fdt
)
162 if (fdt
->free_files
|| fdt
->max_fdset
> __FD_SETSIZE
||
163 fdt
->max_fds
> NR_OPEN_DEFAULT
)
164 call_rcu(&fdt
->rcu
, free_fdtable_rcu
);
168 * Expand the fdset in the files_struct. Called with the files spinlock
171 static void copy_fdtable(struct fdtable
*nfdt
, struct fdtable
*fdt
)
176 BUG_ON(nfdt
->max_fdset
< fdt
->max_fdset
);
177 BUG_ON(nfdt
->max_fds
< fdt
->max_fds
);
178 /* Copy the existing tables and install the new pointers */
180 i
= fdt
->max_fdset
/ (sizeof(unsigned long) * 8);
181 count
= (nfdt
->max_fdset
- fdt
->max_fdset
) / 8;
184 * Don't copy the entire array if the current fdset is
185 * not yet initialised.
188 memcpy (nfdt
->open_fds
, fdt
->open_fds
,
190 memcpy (nfdt
->close_on_exec
, fdt
->close_on_exec
,
192 memset (&nfdt
->open_fds
->fds_bits
[i
], 0, count
);
193 memset (&nfdt
->close_on_exec
->fds_bits
[i
], 0, count
);
196 /* Don't copy/clear the array if we are creating a new
197 fd array for fork() */
199 memcpy(nfdt
->fd
, fdt
->fd
,
200 fdt
->max_fds
* sizeof(struct file
*));
201 /* clear the remainder of the array */
202 memset(&nfdt
->fd
[fdt
->max_fds
], 0,
203 (nfdt
->max_fds
- fdt
->max_fds
) *
204 sizeof(struct file
*));
206 nfdt
->next_fd
= fdt
->next_fd
;
210 * Allocate an fdset array, using kmalloc or vmalloc.
211 * Note: the array isn't cleared at allocation time.
213 fd_set
* alloc_fdset(int num
)
218 if (size
<= PAGE_SIZE
)
219 new_fdset
= (fd_set
*) kmalloc(size
, GFP_KERNEL
);
221 new_fdset
= (fd_set
*) vmalloc(size
);
225 void free_fdset(fd_set
*array
, int num
)
229 if (num
<= __FD_SETSIZE
) /* Don't free an embedded fdset */
231 else if (size
<= PAGE_SIZE
)
237 static struct fdtable
*alloc_fdtable(int nr
)
239 struct fdtable
*fdt
= NULL
;
241 fd_set
*new_openset
= NULL
, *new_execset
= NULL
;
242 struct file
**new_fds
;
244 fdt
= kmalloc(sizeof(*fdt
), GFP_KERNEL
);
247 memset(fdt
, 0, sizeof(*fdt
));
250 /* Expand to the max in easy steps */
252 if (nfds
< (PAGE_SIZE
* 8))
253 nfds
= PAGE_SIZE
* 8;
259 } while (nfds
<= nr
);
261 new_openset
= alloc_fdset(nfds
);
262 new_execset
= alloc_fdset(nfds
);
263 if (!new_openset
|| !new_execset
)
265 fdt
->open_fds
= new_openset
;
266 fdt
->close_on_exec
= new_execset
;
267 fdt
->max_fdset
= nfds
;
269 nfds
= NR_OPEN_DEFAULT
;
271 * Expand to the max in easy steps, and keep expanding it until
272 * we have enough for the requested fd array size.
275 #if NR_OPEN_DEFAULT < 256
280 if (nfds
< (PAGE_SIZE
/ sizeof(struct file
*)))
281 nfds
= PAGE_SIZE
/ sizeof(struct file
*);
287 } while (nfds
<= nr
);
288 new_fds
= alloc_fd_array(nfds
);
293 fdt
->free_files
= NULL
;
297 free_fdset(new_openset
, nfds
);
299 free_fdset(new_execset
, nfds
);
305 * Expands the file descriptor table - it will allocate a new fdtable and
306 * both fd array and fdset. It is expected to be called with the
309 static int expand_fdtable(struct files_struct
*files
, int nr
)
310 __releases(files
->file_lock
)
311 __acquires(files
->file_lock
)
315 struct fdtable
*nfdt
= NULL
;
317 spin_unlock(&files
->file_lock
);
318 nfdt
= alloc_fdtable(nr
);
321 spin_lock(&files
->file_lock
);
325 spin_lock(&files
->file_lock
);
326 fdt
= files_fdtable(files
);
328 * Check again since another task may have expanded the
329 * fd table while we dropped the lock
331 if (nr
>= fdt
->max_fds
|| nr
>= fdt
->max_fdset
) {
332 copy_fdtable(nfdt
, fdt
);
334 /* Somebody expanded while we dropped file_lock */
335 spin_unlock(&files
->file_lock
);
336 __free_fdtable(nfdt
);
337 spin_lock(&files
->file_lock
);
340 rcu_assign_pointer(files
->fdt
, nfdt
);
348 * Return <0 on error; 0 nothing done; 1 files expanded, we may have blocked.
349 * Should be called with the files->file_lock spinlock held for write.
351 int expand_files(struct files_struct
*files
, int nr
)
356 fdt
= files_fdtable(files
);
357 if (nr
>= fdt
->max_fdset
|| nr
>= fdt
->max_fds
) {
358 if (fdt
->max_fdset
>= NR_OPEN
||
359 fdt
->max_fds
>= NR_OPEN
|| nr
>= NR_OPEN
) {
364 if ((err
= expand_fdtable(files
, nr
)))
372 static void __devinit
fdtable_defer_list_init(int cpu
)
374 struct fdtable_defer
*fddef
= &per_cpu(fdtable_defer_list
, cpu
);
375 spin_lock_init(&fddef
->lock
);
376 INIT_WORK(&fddef
->wq
, (void (*)(void *))free_fdtable_work
, fddef
);
377 init_timer(&fddef
->timer
);
378 fddef
->timer
.data
= (unsigned long)fddef
;
379 fddef
->timer
.function
= fdtable_timer
;
383 void __init
files_defer_init(void)
386 /* Really early - can't use for_each_cpu */
387 for (i
= 0; i
< NR_CPUS
; i
++)
388 fdtable_defer_list_init(i
);