cgroup: switch to proc_create()
[linux-2.6] / kernel / resource.c
1 /*
2  *      linux/kernel/resource.c
3  *
4  * Copyright (C) 1999   Linus Torvalds
5  * Copyright (C) 1999   Martin Mares <mj@ucw.cz>
6  *
7  * Arbitrary resource management.
8  */
9
10 #include <linux/module.h>
11 #include <linux/errno.h>
12 #include <linux/ioport.h>
13 #include <linux/init.h>
14 #include <linux/slab.h>
15 #include <linux/spinlock.h>
16 #include <linux/fs.h>
17 #include <linux/proc_fs.h>
18 #include <linux/seq_file.h>
19 #include <linux/device.h>
20 #include <asm/io.h>
21
22
23 struct resource ioport_resource = {
24         .name   = "PCI IO",
25         .start  = 0,
26         .end    = IO_SPACE_LIMIT,
27         .flags  = IORESOURCE_IO,
28 };
29 EXPORT_SYMBOL(ioport_resource);
30
31 struct resource iomem_resource = {
32         .name   = "PCI mem",
33         .start  = 0,
34         .end    = -1,
35         .flags  = IORESOURCE_MEM,
36 };
37 EXPORT_SYMBOL(iomem_resource);
38
39 static DEFINE_RWLOCK(resource_lock);
40
41 #ifdef CONFIG_PROC_FS
42
43 enum { MAX_IORES_LEVEL = 5 };
44
45 static void *r_next(struct seq_file *m, void *v, loff_t *pos)
46 {
47         struct resource *p = v;
48         (*pos)++;
49         if (p->child)
50                 return p->child;
51         while (!p->sibling && p->parent)
52                 p = p->parent;
53         return p->sibling;
54 }
55
56 static void *r_start(struct seq_file *m, loff_t *pos)
57         __acquires(resource_lock)
58 {
59         struct resource *p = m->private;
60         loff_t l = 0;
61         read_lock(&resource_lock);
62         for (p = p->child; p && l < *pos; p = r_next(m, p, &l))
63                 ;
64         return p;
65 }
66
67 static void r_stop(struct seq_file *m, void *v)
68         __releases(resource_lock)
69 {
70         read_unlock(&resource_lock);
71 }
72
73 static int r_show(struct seq_file *m, void *v)
74 {
75         struct resource *root = m->private;
76         struct resource *r = v, *p;
77         int width = root->end < 0x10000 ? 4 : 8;
78         int depth;
79
80         for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
81                 if (p->parent == root)
82                         break;
83         seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
84                         depth * 2, "",
85                         width, (unsigned long long) r->start,
86                         width, (unsigned long long) r->end,
87                         r->name ? r->name : "<BAD>");
88         return 0;
89 }
90
91 static const struct seq_operations resource_op = {
92         .start  = r_start,
93         .next   = r_next,
94         .stop   = r_stop,
95         .show   = r_show,
96 };
97
98 static int ioports_open(struct inode *inode, struct file *file)
99 {
100         int res = seq_open(file, &resource_op);
101         if (!res) {
102                 struct seq_file *m = file->private_data;
103                 m->private = &ioport_resource;
104         }
105         return res;
106 }
107
108 static int iomem_open(struct inode *inode, struct file *file)
109 {
110         int res = seq_open(file, &resource_op);
111         if (!res) {
112                 struct seq_file *m = file->private_data;
113                 m->private = &iomem_resource;
114         }
115         return res;
116 }
117
118 static const struct file_operations proc_ioports_operations = {
119         .open           = ioports_open,
120         .read           = seq_read,
121         .llseek         = seq_lseek,
122         .release        = seq_release,
123 };
124
125 static const struct file_operations proc_iomem_operations = {
126         .open           = iomem_open,
127         .read           = seq_read,
128         .llseek         = seq_lseek,
129         .release        = seq_release,
130 };
131
132 static int __init ioresources_init(void)
133 {
134         struct proc_dir_entry *entry;
135
136         entry = create_proc_entry("ioports", 0, NULL);
137         if (entry)
138                 entry->proc_fops = &proc_ioports_operations;
139         entry = create_proc_entry("iomem", 0, NULL);
140         if (entry)
141                 entry->proc_fops = &proc_iomem_operations;
142         return 0;
143 }
144 __initcall(ioresources_init);
145
146 #endif /* CONFIG_PROC_FS */
147
148 /* Return the conflict entry if you can't request it */
149 static struct resource * __request_resource(struct resource *root, struct resource *new)
150 {
151         resource_size_t start = new->start;
152         resource_size_t end = new->end;
153         struct resource *tmp, **p;
154
155         if (end < start)
156                 return root;
157         if (start < root->start)
158                 return root;
159         if (end > root->end)
160                 return root;
161         p = &root->child;
162         for (;;) {
163                 tmp = *p;
164                 if (!tmp || tmp->start > end) {
165                         new->sibling = tmp;
166                         *p = new;
167                         new->parent = root;
168                         return NULL;
169                 }
170                 p = &tmp->sibling;
171                 if (tmp->end < start)
172                         continue;
173                 return tmp;
174         }
175 }
176
177 static int __release_resource(struct resource *old)
178 {
179         struct resource *tmp, **p;
180
181         p = &old->parent->child;
182         for (;;) {
183                 tmp = *p;
184                 if (!tmp)
185                         break;
186                 if (tmp == old) {
187                         *p = tmp->sibling;
188                         old->parent = NULL;
189                         return 0;
190                 }
191                 p = &tmp->sibling;
192         }
193         return -EINVAL;
194 }
195
196 /**
197  * request_resource - request and reserve an I/O or memory resource
198  * @root: root resource descriptor
199  * @new: resource descriptor desired by caller
200  *
201  * Returns 0 for success, negative error code on error.
202  */
203 int request_resource(struct resource *root, struct resource *new)
204 {
205         struct resource *conflict;
206
207         write_lock(&resource_lock);
208         conflict = __request_resource(root, new);
209         write_unlock(&resource_lock);
210         return conflict ? -EBUSY : 0;
211 }
212
213 EXPORT_SYMBOL(request_resource);
214
215 /**
216  * release_resource - release a previously reserved resource
217  * @old: resource pointer
218  */
219 int release_resource(struct resource *old)
220 {
221         int retval;
222
223         write_lock(&resource_lock);
224         retval = __release_resource(old);
225         write_unlock(&resource_lock);
226         return retval;
227 }
228
229 EXPORT_SYMBOL(release_resource);
230
231 #if defined(CONFIG_MEMORY_HOTPLUG) && !defined(CONFIG_ARCH_HAS_WALK_MEMORY)
232 /*
233  * Finds the lowest memory reosurce exists within [res->start.res->end)
234  * the caller must specify res->start, res->end, res->flags.
235  * If found, returns 0, res is overwritten, if not found, returns -1.
236  */
237 static int find_next_system_ram(struct resource *res)
238 {
239         resource_size_t start, end;
240         struct resource *p;
241
242         BUG_ON(!res);
243
244         start = res->start;
245         end = res->end;
246         BUG_ON(start >= end);
247
248         read_lock(&resource_lock);
249         for (p = iomem_resource.child; p ; p = p->sibling) {
250                 /* system ram is just marked as IORESOURCE_MEM */
251                 if (p->flags != res->flags)
252                         continue;
253                 if (p->start > end) {
254                         p = NULL;
255                         break;
256                 }
257                 if ((p->end >= start) && (p->start < end))
258                         break;
259         }
260         read_unlock(&resource_lock);
261         if (!p)
262                 return -1;
263         /* copy data */
264         if (res->start < p->start)
265                 res->start = p->start;
266         if (res->end > p->end)
267                 res->end = p->end;
268         return 0;
269 }
270 int
271 walk_memory_resource(unsigned long start_pfn, unsigned long nr_pages, void *arg,
272                         int (*func)(unsigned long, unsigned long, void *))
273 {
274         struct resource res;
275         unsigned long pfn, len;
276         u64 orig_end;
277         int ret = -1;
278         res.start = (u64) start_pfn << PAGE_SHIFT;
279         res.end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1;
280         res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
281         orig_end = res.end;
282         while ((res.start < res.end) && (find_next_system_ram(&res) >= 0)) {
283                 pfn = (unsigned long)(res.start >> PAGE_SHIFT);
284                 len = (unsigned long)((res.end + 1 - res.start) >> PAGE_SHIFT);
285                 ret = (*func)(pfn, len, arg);
286                 if (ret)
287                         break;
288                 res.start = res.end + 1;
289                 res.end = orig_end;
290         }
291         return ret;
292 }
293
294 #endif
295
296 /*
297  * Find empty slot in the resource tree given range and alignment.
298  */
299 static int find_resource(struct resource *root, struct resource *new,
300                          resource_size_t size, resource_size_t min,
301                          resource_size_t max, resource_size_t align,
302                          void (*alignf)(void *, struct resource *,
303                                         resource_size_t, resource_size_t),
304                          void *alignf_data)
305 {
306         struct resource *this = root->child;
307
308         new->start = root->start;
309         /*
310          * Skip past an allocated resource that starts at 0, since the assignment
311          * of this->start - 1 to new->end below would cause an underflow.
312          */
313         if (this && this->start == 0) {
314                 new->start = this->end + 1;
315                 this = this->sibling;
316         }
317         for(;;) {
318                 if (this)
319                         new->end = this->start - 1;
320                 else
321                         new->end = root->end;
322                 if (new->start < min)
323                         new->start = min;
324                 if (new->end > max)
325                         new->end = max;
326                 new->start = ALIGN(new->start, align);
327                 if (alignf)
328                         alignf(alignf_data, new, size, align);
329                 if (new->start < new->end && new->end - new->start >= size - 1) {
330                         new->end = new->start + size - 1;
331                         return 0;
332                 }
333                 if (!this)
334                         break;
335                 new->start = this->end + 1;
336                 this = this->sibling;
337         }
338         return -EBUSY;
339 }
340
341 /**
342  * allocate_resource - allocate empty slot in the resource tree given range & alignment
343  * @root: root resource descriptor
344  * @new: resource descriptor desired by caller
345  * @size: requested resource region size
346  * @min: minimum size to allocate
347  * @max: maximum size to allocate
348  * @align: alignment requested, in bytes
349  * @alignf: alignment function, optional, called if not NULL
350  * @alignf_data: arbitrary data to pass to the @alignf function
351  */
352 int allocate_resource(struct resource *root, struct resource *new,
353                       resource_size_t size, resource_size_t min,
354                       resource_size_t max, resource_size_t align,
355                       void (*alignf)(void *, struct resource *,
356                                      resource_size_t, resource_size_t),
357                       void *alignf_data)
358 {
359         int err;
360
361         write_lock(&resource_lock);
362         err = find_resource(root, new, size, min, max, align, alignf, alignf_data);
363         if (err >= 0 && __request_resource(root, new))
364                 err = -EBUSY;
365         write_unlock(&resource_lock);
366         return err;
367 }
368
369 EXPORT_SYMBOL(allocate_resource);
370
371 /**
372  * insert_resource - Inserts a resource in the resource tree
373  * @parent: parent of the new resource
374  * @new: new resource to insert
375  *
376  * Returns 0 on success, -EBUSY if the resource can't be inserted.
377  *
378  * This function is equivalent to request_resource when no conflict
379  * happens. If a conflict happens, and the conflicting resources
380  * entirely fit within the range of the new resource, then the new
381  * resource is inserted and the conflicting resources become children of
382  * the new resource.
383  */
384 int insert_resource(struct resource *parent, struct resource *new)
385 {
386         int result;
387         struct resource *first, *next;
388
389         write_lock(&resource_lock);
390
391         for (;; parent = first) {
392                 result = 0;
393                 first = __request_resource(parent, new);
394                 if (!first)
395                         goto out;
396
397                 result = -EBUSY;
398                 if (first == parent)
399                         goto out;
400
401                 if ((first->start > new->start) || (first->end < new->end))
402                         break;
403                 if ((first->start == new->start) && (first->end == new->end))
404                         break;
405         }
406
407         for (next = first; ; next = next->sibling) {
408                 /* Partial overlap? Bad, and unfixable */
409                 if (next->start < new->start || next->end > new->end)
410                         goto out;
411                 if (!next->sibling)
412                         break;
413                 if (next->sibling->start > new->end)
414                         break;
415         }
416
417         result = 0;
418
419         new->parent = parent;
420         new->sibling = next->sibling;
421         new->child = first;
422
423         next->sibling = NULL;
424         for (next = first; next; next = next->sibling)
425                 next->parent = new;
426
427         if (parent->child == first) {
428                 parent->child = new;
429         } else {
430                 next = parent->child;
431                 while (next->sibling != first)
432                         next = next->sibling;
433                 next->sibling = new;
434         }
435
436  out:
437         write_unlock(&resource_lock);
438         return result;
439 }
440
441 /**
442  * adjust_resource - modify a resource's start and size
443  * @res: resource to modify
444  * @start: new start value
445  * @size: new size
446  *
447  * Given an existing resource, change its start and size to match the
448  * arguments.  Returns 0 on success, -EBUSY if it can't fit.
449  * Existing children of the resource are assumed to be immutable.
450  */
451 int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)
452 {
453         struct resource *tmp, *parent = res->parent;
454         resource_size_t end = start + size - 1;
455         int result = -EBUSY;
456
457         write_lock(&resource_lock);
458
459         if ((start < parent->start) || (end > parent->end))
460                 goto out;
461
462         for (tmp = res->child; tmp; tmp = tmp->sibling) {
463                 if ((tmp->start < start) || (tmp->end > end))
464                         goto out;
465         }
466
467         if (res->sibling && (res->sibling->start <= end))
468                 goto out;
469
470         tmp = parent->child;
471         if (tmp != res) {
472                 while (tmp->sibling != res)
473                         tmp = tmp->sibling;
474                 if (start <= tmp->end)
475                         goto out;
476         }
477
478         res->start = start;
479         res->end = end;
480         result = 0;
481
482  out:
483         write_unlock(&resource_lock);
484         return result;
485 }
486
487 EXPORT_SYMBOL(adjust_resource);
488
489 /**
490  * resource_alignment - calculate resource's alignment
491  * @res: resource pointer
492  *
493  * Returns alignment on success, 0 (invalid alignment) on failure.
494  */
495 resource_size_t resource_alignment(struct resource *res)
496 {
497         switch (res->flags & (IORESOURCE_SIZEALIGN | IORESOURCE_STARTALIGN)) {
498         case IORESOURCE_SIZEALIGN:
499                 return res->end - res->start + 1;
500         case IORESOURCE_STARTALIGN:
501                 return res->start;
502         default:
503                 return 0;
504         }
505 }
506
507 /*
508  * This is compatibility stuff for IO resources.
509  *
510  * Note how this, unlike the above, knows about
511  * the IO flag meanings (busy etc).
512  *
513  * request_region creates a new busy region.
514  *
515  * check_region returns non-zero if the area is already busy.
516  *
517  * release_region releases a matching busy region.
518  */
519
520 /**
521  * __request_region - create a new busy resource region
522  * @parent: parent resource descriptor
523  * @start: resource start address
524  * @n: resource region size
525  * @name: reserving caller's ID string
526  */
527 struct resource * __request_region(struct resource *parent,
528                                    resource_size_t start, resource_size_t n,
529                                    const char *name)
530 {
531         struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
532
533         if (res) {
534                 res->name = name;
535                 res->start = start;
536                 res->end = start + n - 1;
537                 res->flags = IORESOURCE_BUSY;
538
539                 write_lock(&resource_lock);
540
541                 for (;;) {
542                         struct resource *conflict;
543
544                         conflict = __request_resource(parent, res);
545                         if (!conflict)
546                                 break;
547                         if (conflict != parent) {
548                                 parent = conflict;
549                                 if (!(conflict->flags & IORESOURCE_BUSY))
550                                         continue;
551                         }
552
553                         /* Uhhuh, that didn't work out.. */
554                         kfree(res);
555                         res = NULL;
556                         break;
557                 }
558                 write_unlock(&resource_lock);
559         }
560         return res;
561 }
562 EXPORT_SYMBOL(__request_region);
563
564 /**
565  * __check_region - check if a resource region is busy or free
566  * @parent: parent resource descriptor
567  * @start: resource start address
568  * @n: resource region size
569  *
570  * Returns 0 if the region is free at the moment it is checked,
571  * returns %-EBUSY if the region is busy.
572  *
573  * NOTE:
574  * This function is deprecated because its use is racy.
575  * Even if it returns 0, a subsequent call to request_region()
576  * may fail because another driver etc. just allocated the region.
577  * Do NOT use it.  It will be removed from the kernel.
578  */
579 int __check_region(struct resource *parent, resource_size_t start,
580                         resource_size_t n)
581 {
582         struct resource * res;
583
584         res = __request_region(parent, start, n, "check-region");
585         if (!res)
586                 return -EBUSY;
587
588         release_resource(res);
589         kfree(res);
590         return 0;
591 }
592 EXPORT_SYMBOL(__check_region);
593
594 /**
595  * __release_region - release a previously reserved resource region
596  * @parent: parent resource descriptor
597  * @start: resource start address
598  * @n: resource region size
599  *
600  * The described resource region must match a currently busy region.
601  */
602 void __release_region(struct resource *parent, resource_size_t start,
603                         resource_size_t n)
604 {
605         struct resource **p;
606         resource_size_t end;
607
608         p = &parent->child;
609         end = start + n - 1;
610
611         write_lock(&resource_lock);
612
613         for (;;) {
614                 struct resource *res = *p;
615
616                 if (!res)
617                         break;
618                 if (res->start <= start && res->end >= end) {
619                         if (!(res->flags & IORESOURCE_BUSY)) {
620                                 p = &res->child;
621                                 continue;
622                         }
623                         if (res->start != start || res->end != end)
624                                 break;
625                         *p = res->sibling;
626                         write_unlock(&resource_lock);
627                         kfree(res);
628                         return;
629                 }
630                 p = &res->sibling;
631         }
632
633         write_unlock(&resource_lock);
634
635         printk(KERN_WARNING "Trying to free nonexistent resource "
636                 "<%016llx-%016llx>\n", (unsigned long long)start,
637                 (unsigned long long)end);
638 }
639 EXPORT_SYMBOL(__release_region);
640
641 /*
642  * Managed region resource
643  */
644 struct region_devres {
645         struct resource *parent;
646         resource_size_t start;
647         resource_size_t n;
648 };
649
650 static void devm_region_release(struct device *dev, void *res)
651 {
652         struct region_devres *this = res;
653
654         __release_region(this->parent, this->start, this->n);
655 }
656
657 static int devm_region_match(struct device *dev, void *res, void *match_data)
658 {
659         struct region_devres *this = res, *match = match_data;
660
661         return this->parent == match->parent &&
662                 this->start == match->start && this->n == match->n;
663 }
664
665 struct resource * __devm_request_region(struct device *dev,
666                                 struct resource *parent, resource_size_t start,
667                                 resource_size_t n, const char *name)
668 {
669         struct region_devres *dr = NULL;
670         struct resource *res;
671
672         dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
673                           GFP_KERNEL);
674         if (!dr)
675                 return NULL;
676
677         dr->parent = parent;
678         dr->start = start;
679         dr->n = n;
680
681         res = __request_region(parent, start, n, name);
682         if (res)
683                 devres_add(dev, dr);
684         else
685                 devres_free(dr);
686
687         return res;
688 }
689 EXPORT_SYMBOL(__devm_request_region);
690
691 void __devm_release_region(struct device *dev, struct resource *parent,
692                            resource_size_t start, resource_size_t n)
693 {
694         struct region_devres match_data = { parent, start, n };
695
696         __release_region(parent, start, n);
697         WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
698                                &match_data));
699 }
700 EXPORT_SYMBOL(__devm_release_region);
701
702 /*
703  * Called from init/main.c to reserve IO ports.
704  */
705 #define MAXRESERVE 4
706 static int __init reserve_setup(char *str)
707 {
708         static int reserved;
709         static struct resource reserve[MAXRESERVE];
710
711         for (;;) {
712                 int io_start, io_num;
713                 int x = reserved;
714
715                 if (get_option (&str, &io_start) != 2)
716                         break;
717                 if (get_option (&str, &io_num)   == 0)
718                         break;
719                 if (x < MAXRESERVE) {
720                         struct resource *res = reserve + x;
721                         res->name = "reserved";
722                         res->start = io_start;
723                         res->end = io_start + io_num - 1;
724                         res->flags = IORESOURCE_BUSY;
725                         res->child = NULL;
726                         if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
727                                 reserved = x+1;
728                 }
729         }
730         return 1;
731 }
732
733 __setup("reserve=", reserve_setup);