?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.1.118
[davej-history.git] / fs / proc / openpromfs.c
blobb3871059e14bd35ba11dd953993e2bbea02aa96f
1 /* $Id: openpromfs.c,v 1.26 1998/01/28 09:55:32 ecd Exp $
2 * openpromfs.c: /proc/openprom handling routines
3 *
4 * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
5 */
6
7 #include <linux/module.h>
8 #include <linux/types.h>
9 #include <linux/string.h>
10 #include <linux/fs.h>
11 #include <linux/proc_fs.h>
12 #include <linux/init.h>
13
14 #include <asm/openprom.h>
15 #include <asm/oplib.h>
16 #include <asm/uaccess.h>
17
18 #define ALIASES_NNODES 64
19
20 typedef struct {
21 u16 parent;
22 u16 next;
23 u16 child;
24 u16 first_prop;
25 u32 node;
26 } openpromfs_node;
27
28 typedef struct {
29 #define OPP_STRING 0x10
30 #define OPP_BINARY 0x20
31 #define OPP_DIRTY 0x01
32 #define OPP_QUOTED 0x02
33 #define OPP_NOTQUOTED 0x04
34 #define OPP_ASCIIZ 0x08
35 u32 flag;
36 u32 alloclen;
37 u32 len;
38 char *value;
39 char name[8];
40 } openprom_property;
41
42 static openpromfs_node *nodes = NULL;
43 static int alloced = 0;
44 static u16 last_node = 0;
45 static u16 first_prop = 0;
46 static u16 options = 0xffff;
47 static u16 aliases = 0xffff;
48 static int aliases_nodes = 0;
49 static char *alias_names [ALIASES_NNODES];
50 static struct inode_operations *proc_openprom_iops = 0;
51 static struct openpromfs_dev **devices;
52
53 #define NODE(ino) nodes[ino - PROC_OPENPROM_FIRST]
54 #define NODE2INO(node) (node + PROC_OPENPROM_FIRST)
55 #define NODEP2INO(no) (no + PROC_OPENPROM_FIRST + last_node)
56
57 static int openpromfs_create (struct inode *, struct dentry *, int);
58 static int openpromfs_readdir(struct file *, void *, filldir_t);
59 static int openpromfs_lookup(struct inode *, struct dentry *dentry);
60 static int openpromfs_unlink (struct inode *, struct dentry *dentry);
61
62 static ssize_t nodenum_read(struct file *file, char *buf,
63 size_t count, loff_t *ppos)
64 {
65 struct inode *inode = file->f_dentry->d_inode;
66 char buffer[10];
67
68 if (count < 0 || !inode->u.generic_ip)
69 return -EINVAL;
70 sprintf (buffer, "%8.8x\n", (u32)(long)(inode->u.generic_ip));
71 if (file->f_pos >= 9)
72 return 0;
73 if (count > 9 - file->f_pos)
74 count = 9 - file->f_pos;
75 copy_to_user(buf, buffer + file->f_pos, count);
76 file->f_pos += count;
77 return count;
78 }
79
80 static ssize_t property_read(struct file *filp, char *buf,
81 size_t count, loff_t *ppos)
82 {
83 struct inode *inode = filp->f_dentry->d_inode;
84 int i, j, k;
85 u32 node;
86 char *p;
87 u32 *q;
88 openprom_property *op;
89 char buffer[64];
90
91 if (filp->f_pos >= 0xffffff)
92 return -EINVAL;
93 if (!filp->private_data) {
94 node = nodes[(u16)((long)inode->u.generic_ip)].node;
95 i = ((u32)(long)inode->u.generic_ip) >> 16;
96 if ((u16)((long)inode->u.generic_ip) == aliases) {
97 if (i >= aliases_nodes)
98 p = 0;
99 else
100 p = alias_names [i];
101 } else
102 for (p = prom_firstprop (node, buffer);
103 i && p && *p;
104 p = prom_nextprop (node, p, buffer), i--)
105 /* nothing */ ;
106 if (!p || !*p)
107 return -EIO;
108 i = prom_getproplen (node, p);
109 if (i < 0) {
110 if ((u16)((long)inode->u.generic_ip) == aliases)
111 i = 0;
112 else
113 return -EIO;
114 }
115 k = i;
116 if (i < 64) i = 64;
117 filp->private_data = kmalloc (sizeof (openprom_property)
118 + (j = strlen (p)) + 2 * i,
119 GFP_KERNEL);
120 if (!filp->private_data)
121 return -ENOMEM;
122 op = (openprom_property *)filp->private_data;
123 op->flag = 0;
124 op->alloclen = 2 * i;
125 strcpy (op->name, p);
126 op->value = (char *)(((unsigned long)(op->name + j + 4)) & ~3);
127 op->len = k;
128 if (k && prom_getproperty (node, p, op->value, i) < 0)
129 return -EIO;
130 op->value [k] = 0;
131 if (k) {
132 for (p = op->value; *p >= ' ' && *p <= '~'; p++);
133 if (p >= op->value + k - 1 && !*p) {
134 op->flag |= OPP_STRING;
135 if (p == op->value + k - 1) {
136 op->flag |= OPP_ASCIIZ;
137 op->len--;
138 }
139 } else if (!(k & 3))
140 op->flag |= OPP_BINARY;
141 else {
142 printk ("/proc/openprom: Strange property "
143 "size %d\n", i);
144 return -EIO;
145 }
146 }
147 } else
148 op = (openprom_property *)filp->private_data;
149 if (!count || !op->len) return 0;
150 if (op->flag & OPP_STRING)
151 i = op->len + 3;
152 else
153 i = (op->len * 9)>>2;
154 k = filp->f_pos;
155 if (k >= i) return 0;
156 if (count > i - k) count = i - k;
157 if (op->flag & OPP_STRING) {
158 if (!k) {
159 __put_user('\'', buf);
160 k++;
161 count--;
162 }
163 if (k + count >= i - 2)
164 j = i - 2 - k;
165 else
166 j = count;
167 if (j >= 0) {
168 copy_to_user(buf + k - filp->f_pos,
169 op->value + k - 1, j);
170 count -= j;
171 k += j;
172 }
173 if (count)
174 __put_user('\'', &buf [k++ - filp->f_pos]);
175 if (count > 1)
176 __put_user('\n', &buf [k++ - filp->f_pos]);
177 } else if (op->flag & OPP_BINARY) {
178 char buffer[10];
179 u32 *first, *last;
180 int first_off, last_cnt;
181
182 first = ((u32 *)op->value) + k / 9;
183 first_off = k % 9;
184 last = ((u32 *)op->value) + (k + count - 1) / 9;
185 last_cnt = (k + count) % 9;
186 if (!last_cnt) last_cnt = 9;
187
188 if (first == last) {
189 sprintf (buffer, "%08x.", *first);
190 copy_to_user (buf, buffer + first_off, last_cnt - first_off);
191 buf += last_cnt - first_off;
192 } else {
193 for (q = first; q <= last; q++) {
194 sprintf (buffer, "%08x.", *q);
195 if (q == first) {
196 copy_to_user (buf, buffer + first_off,
197 9 - first_off);
198 buf += 9 - first_off;
199 } else if (q == last) {
200 copy_to_user (buf, buffer, last_cnt);
201 buf += last_cnt;
202 } else {
203 copy_to_user (buf, buffer, 9);
204 buf += 9;
205 }
206 }
207 }
208 if (last == (u32 *)(op->value + op->len - 4) && last_cnt == 9)
209 __put_user('\n', (buf - 1));
210 k += count;
211 }
212 count = k - filp->f_pos;
213 filp->f_pos = k;
214 return count;
215 }
216
217 static ssize_t property_write(struct file *filp, const char *buf,
218 size_t count, loff_t *ppos)
219 {
220 int i, j, k;
221 char *p;
222 u32 *q;
223 void *b;
224 openprom_property *op;
225
226 if (filp->f_pos >= 0xffffff)
227 return -EINVAL;
228 if (!filp->private_data) {
229 i = property_read (filp, NULL, 0, 0);
230 if (i)
231 return i;
232 }
233 k = filp->f_pos;
234 op = (openprom_property *)filp->private_data;
235 if (!(op->flag & OPP_STRING)) {
236 u32 *first, *last;
237 int first_off, last_cnt;
238 u32 mask, mask2;
239 char tmp [9];
240 int forcelen = 0;
241
242 j = k % 9;
243 for (i = 0; i < count; i++, j++) {
244 if (j == 9) j = 0;
245 if (!j) {
246 char ctmp;
247 __get_user(ctmp, &buf[i]);
248 if (ctmp != '.') {
249 if (ctmp != '\n') {
250 if (op->flag & OPP_BINARY)
251 return -EINVAL;
252 else
253 goto write_try_string;
254 } else {
255 count = i + 1;
256 forcelen = 1;
257 break;
258 }
259 }
260 } else {
261 char ctmp;
262 __get_user(ctmp, &buf[i]);
263 if (ctmp < '0' ||
264 (ctmp > '9' && ctmp < 'A') ||
265 (ctmp > 'F' && ctmp < 'a') ||
266 ctmp > 'f') {
267 if (op->flag & OPP_BINARY)
268 return -EINVAL;
269 else
270 goto write_try_string;
271 }
272 }
273 }
274 op->flag |= OPP_BINARY;
275 tmp [8] = 0;
276 i = ((count + k + 8) / 9) << 2;
277 if (op->alloclen <= i) {
278 b = kmalloc (sizeof (openprom_property) + 2 * i,
279 GFP_KERNEL);
280 if (!b)
281 return -ENOMEM;
282 memcpy (b, filp->private_data,
283 sizeof (openprom_property)
284 + strlen (op->name) + op->alloclen);
285 memset (((char *)b) + sizeof (openprom_property)
286 + strlen (op->name) + op->alloclen,
287 0, 2 * i - op->alloclen);
288 op = (openprom_property *)b;
289 op->alloclen = 2*i;
290 b = filp->private_data;
291 filp->private_data = (void *)op;
292 kfree (b);
293 }
294 first = ((u32 *)op->value) + (k / 9);
295 first_off = k % 9;
296 last = (u32 *)(op->value + i);
297 last_cnt = (k + count) % 9;
298 if (first + 1 == last) {
299 memset (tmp, '0', 8);
300 copy_from_user (tmp + first_off, buf,
301 (count + first_off > 8) ? 8 - first_off : count);
302 mask = 0xffffffff;
303 mask2 = 0xffffffff;
304 for (j = 0; j < first_off; j++)
305 mask >>= 1;
306 for (j = 8 - count - first_off; j > 0; j--)
307 mask2 <<= 1;
308 mask &= mask2;
309 if (mask) {
310 *first &= ~mask;
311 *first |= simple_strtoul (tmp, 0, 16);
312 op->flag |= OPP_DIRTY;
313 }
314 } else {
315 op->flag |= OPP_DIRTY;
316 for (q = first; q < last; q++) {
317 if (q == first) {
318 if (first_off < 8) {
319 memset (tmp, '0', 8);
320 copy_from_user (tmp + first_off, buf,
321 8 - first_off);
322 mask = 0xffffffff;
323 for (j = 0; j < first_off; j++)
324 mask >>= 1;
325 *q &= ~mask;
326 *q |= simple_strtoul (tmp,0,16);
327 }
328 buf += 9;
329 } else if ((q == last - 1) && last_cnt
330 && (last_cnt < 8)) {
331 memset (tmp, '0', 8);
332 copy_from_user (tmp, buf, last_cnt);
333 mask = 0xffffffff;
334 for (j = 0; j < 8 - last_cnt; j++)
335 mask <<= 1;
336 *q &= ~mask;
337 *q |= simple_strtoul (tmp, 0, 16);
338 buf += last_cnt;
339 } else {
340 char tchars[17]; /* XXX yuck... */
341
342 copy_from_user(tchars, buf, 16);
343 *q = simple_strtoul (tchars, 0, 16);
344 buf += 9;
345 }
346 }
347 }
348 if (!forcelen) {
349 if (op->len < i)
350 op->len = i;
351 } else
352 op->len = i;
353 filp->f_pos += count;
354 }
355 write_try_string:
356 if (!(op->flag & OPP_BINARY)) {
357 if (!(op->flag & (OPP_QUOTED | OPP_NOTQUOTED))) {
358 char ctmp;
359
360 /* No way, if somebody starts writing from the middle,
361 * we don't know whether he uses quotes around or not
362 */
363 if (k > 0)
364 return -EINVAL;
365 __get_user(ctmp, buf);
366 if (ctmp == '\'') {
367 op->flag |= OPP_QUOTED;
368 buf++;
369 count--;
370 filp->f_pos++;
371 if (!count) {
372 op->flag |= OPP_STRING;
373 return 1;
374 }
375 } else
376 op->flag |= OPP_NOTQUOTED;
377 }
378 op->flag |= OPP_STRING;
379 if (op->alloclen <= count + filp->f_pos) {
380 b = kmalloc (sizeof (openprom_property)
381 + 2 * (count + filp->f_pos), GFP_KERNEL);
382 if (!b)
383 return -ENOMEM;
384 memcpy (b, filp->private_data,
385 sizeof (openprom_property)
386 + strlen (op->name) + op->alloclen);
387 memset (((char *)b) + sizeof (openprom_property)
388 + strlen (op->name) + op->alloclen,
389 0, 2*(count - filp->f_pos) - op->alloclen);
390 op = (openprom_property *)b;
391 op->alloclen = 2*(count + filp->f_pos);
392 b = filp->private_data;
393 filp->private_data = (void *)op;
394 kfree (b);
395 }
396 p = op->value + filp->f_pos - ((op->flag & OPP_QUOTED) ? 1 : 0);
397 copy_from_user (p, buf, count);
398 op->flag |= OPP_DIRTY;
399 for (i = 0; i < count; i++, p++)
400 if (*p == '\n') {
401 *p = 0;
402 break;
403 }
404 if (i < count) {
405 op->len = p - op->value;
406 filp->f_pos += i + 1;
407 if ((p > op->value) && (op->flag & OPP_QUOTED)
408 && (*(p - 1) == '\''))
409 op->len--;
410 } else {
411 if (p - op->value > op->len)
412 op->len = p - op->value;
413 filp->f_pos += count;
414 }
415 }
416 return filp->f_pos - k;
417 }
418
419 int property_release (struct inode *inode, struct file *filp)
420 {
421 openprom_property *op = (openprom_property *)filp->private_data;
422 unsigned long flags;
423 int error;
424 u32 node;
425
426 if (!op)
427 return 0;
428 node = nodes[(u16)((long)inode->u.generic_ip)].node;
429 if ((u16)((long)inode->u.generic_ip) == aliases) {
430 if ((op->flag & OPP_DIRTY) && (op->flag & OPP_STRING)) {
431 char *p = op->name;
432 int i = (op->value - op->name) - strlen (op->name) - 1;
433 op->value [op->len] = 0;
434 *(op->value - 1) = ' ';
435 if (i) {
436 for (p = op->value - i - 2; p >= op->name; p--)
437 p[i] = *p;
438 p = op->name + i;
439 }
440 memcpy (p - 8, "nvalias ", 8);
441 prom_feval (p - 8);
442 }
443 } else if (op->flag & OPP_DIRTY) {
444 if (op->flag & OPP_STRING) {
445 op->value [op->len] = 0;
446 save_and_cli (flags);
447 error = prom_setprop (node, op->name,
448 op->value, op->len + 1);
449 restore_flags (flags);
450 if (error <= 0)
451 printk (KERN_WARNING "/proc/openprom: "
452 "Couldn't write property %s\n",
453 op->name);
454 } else if ((op->flag & OPP_BINARY) || !op->len) {
455 save_and_cli (flags);
456 error = prom_setprop (node, op->name,
457 op->value, op->len);
458 restore_flags (flags);
459 if (error <= 0)
460 printk (KERN_WARNING "/proc/openprom: "
461 "Couldn't write property %s\n",
462 op->name);
463 } else {
464 printk (KERN_WARNING "/proc/openprom: "
465 "Unknown property type of %s\n",
466 op->name);
467 }
468 }
469 kfree (filp->private_data);
470 return 0;
471 }
472
473 static struct file_operations openpromfs_prop_ops = {
474 NULL, /* lseek - default */
475 property_read, /* read */
476 property_write, /* write - bad */
477 NULL, /* readdir */
478 NULL, /* poll - default */
479 NULL, /* ioctl - default */
480 NULL, /* mmap */
481 NULL, /* no special open code */
482 NULL, /* flush */
483 property_release, /* no special release code */
484 NULL /* can't fsync */
485 };
486
487 static struct inode_operations openpromfs_prop_inode_ops = {
488 &openpromfs_prop_ops, /* default property file-ops */
489 NULL, /* create */
490 NULL, /* lookup */
491 NULL, /* link */
492 NULL, /* unlink */
493 NULL, /* symlink */
494 NULL, /* mkdir */
495 NULL, /* rmdir */
496 NULL, /* mknod */
497 NULL, /* rename */
498 NULL, /* readlink */
499 NULL, /* follow_link */
500 NULL, /* readpage */
501 NULL, /* writepage */
502 NULL, /* bmap */
503 NULL, /* truncate */
504 NULL /* permission */
505 };
506
507 static struct file_operations openpromfs_nodenum_ops = {
508 NULL, /* lseek - default */
509 nodenum_read, /* read */
510 NULL, /* write - bad */
511 NULL, /* readdir */
512 NULL, /* poll - default */
513 NULL, /* ioctl - default */
514 NULL, /* mmap */
515 NULL, /* no special open code */
516 NULL, /* flush */
517 NULL, /* no special release code */
518 NULL /* can't fsync */
519 };
520
521 static struct inode_operations openpromfs_nodenum_inode_ops = {
522 &openpromfs_nodenum_ops,/* default .node file-ops */
523 NULL, /* create */
524 NULL, /* lookup */
525 NULL, /* link */
526 NULL, /* unlink */
527 NULL, /* symlink */
528 NULL, /* mkdir */
529 NULL, /* rmdir */
530 NULL, /* mknod */
531 NULL, /* rename */
532 NULL, /* readlink */
533 NULL, /* follow_link */
534 NULL, /* readpage */
535 NULL, /* writepage */
536 NULL, /* bmap */
537 NULL, /* truncate */
538 NULL /* permission */
539 };
540
541 static struct file_operations openprom_alias_operations = {
542 NULL, /* lseek - default */
543 NULL, /* read - bad */
544 NULL, /* write - bad */
545 openpromfs_readdir, /* readdir */
546 NULL, /* poll - default */
547 NULL, /* ioctl - default */
548 NULL, /* mmap */
549 NULL, /* no special open code */
550 NULL, /* flush */
551 NULL, /* no special release code */
552 NULL /* can't fsync */
553 };
554
555 static struct inode_operations openprom_alias_inode_operations = {
556 &openprom_alias_operations,/* default aliases directory file-ops */
557 openpromfs_create, /* create */
558 openpromfs_lookup, /* lookup */
559 NULL, /* link */
560 openpromfs_unlink, /* unlink */
561 NULL, /* symlink */
562 NULL, /* mkdir */
563 NULL, /* rmdir */
564 NULL, /* mknod */
565 NULL, /* rename */
566 NULL, /* readlink */
567 NULL, /* follow_link */
568 NULL, /* readpage */
569 NULL, /* writepage */
570 NULL, /* bmap */
571 NULL, /* truncate */
572 NULL /* permission */
573 };
574
575 static int lookup_children(u16 n, const char * name, int len)
576 {
577 int ret;
578 u16 node;
579 for (; n != 0xffff; n = nodes[n].next) {
580 node = nodes[n].child;
581 if (node != 0xffff) {
582 char buffer[128];
583 int i;
584 char *p;
585
586 while (node != 0xffff) {
587 if (prom_getname (nodes[node].node,
588 buffer, 128) >= 0) {
589 i = strlen (buffer);
590 if ((len == i)
591 && !strncmp (buffer, name, len))
592 return NODE2INO(node);
593 p = strchr (buffer, '@');
594 if (p && (len == p - buffer)
595 && !strncmp (buffer, name, len))
596 return NODE2INO(node);
597 }
598 node = nodes[node].next;
599 }
600 } else
601 continue;
602 ret = lookup_children (nodes[n].child, name, len);
603 if (ret) return ret;
604 }
605 return 0;
606 }
607
608 static int openpromfs_lookup(struct inode * dir, struct dentry *dentry)
609 {
610 int ino = 0;
611 #define OPFSL_DIR 0
612 #define OPFSL_PROPERTY 1
613 #define OPFSL_NODENUM 2
614 #define OPFSL_DEVICE 3
615 int type = 0;
616 char buffer[128];
617 char *p;
618 const char *name;
619 u32 n;
620 u16 dirnode;
621 unsigned int len;
622 int i;
623 struct inode *inode;
624 struct openpromfs_dev *d = NULL;
625 char buffer2[64];
626
627 inode = NULL;
628 name = dentry->d_name.name;
629 len = dentry->d_name.len;
630 if (name [0] == '.' && len == 5 && !strncmp (name + 1, "node", 4)) {
631 ino = NODEP2INO(NODE(dir->i_ino).first_prop);
632 type = OPFSL_NODENUM;
633 }
634 if (!ino) {
635 u16 node = NODE(dir->i_ino).child;
636 while (node != 0xffff) {
637 if (prom_getname (nodes[node].node, buffer, 128) >= 0) {
638 i = strlen (buffer);
639 if (len == i && !strncmp (buffer, name, len)) {
640 ino = NODE2INO(node);
641 type = OPFSL_DIR;
642 break;
643 }
644 p = strchr (buffer, '@');
645 if (p && (len == p - buffer)
646 && !strncmp (buffer, name, len)) {
647 ino = NODE2INO(node);
648 type = OPFSL_DIR;
649 break;
650 }
651 }
652 node = nodes[node].next;
653 }
654 }
655 n = NODE(dir->i_ino).node;
656 dirnode = dir->i_ino - PROC_OPENPROM_FIRST;
657 if (!ino) {
658 int j = NODEP2INO(NODE(dir->i_ino).first_prop);
659 if (dirnode != aliases) {
660 for (p = prom_firstprop (n, buffer2);
661 p && *p;
662 p = prom_nextprop (n, p, buffer2)) {
663 j++;
664 if ((len == strlen (p))
665 && !strncmp (p, name, len)) {
666 ino = j;
667 type = OPFSL_PROPERTY;
668 break;
669 }
670 }
671 } else {
672 int k;
673 for (k = 0; k < aliases_nodes; k++) {
674 j++;
675 if (alias_names [k]
676 && (len == strlen (alias_names [k]))
677 && !strncmp (alias_names [k], name, len)) {
678 ino = j;
679 type = OPFSL_PROPERTY;
680 break;
681 }
682 }
683 }
684 }
685 if (!ino) {
686 for (d = *devices; d; d = d->next)
687 if ((d->node == n) && (strlen (d->name) == len)
688 && !strncmp (d->name, name, len)) {
689 ino = d->inode;
690 type = OPFSL_DEVICE;
691 break;
692 }
693 }
694 if (!ino) {
695 ino = lookup_children (NODE(dir->i_ino).child, name, len);
696 if (ino)
697 type = OPFSL_DIR;
698 else
699 return -ENOENT;
700 }
701 inode = proc_get_inode (dir->i_sb, ino, 0);
702 if (!inode)
703 return -EINVAL;
704 switch (type) {
705 case OPFSL_DIR:
706 inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
707 if (ino == PROC_OPENPROM_FIRST + aliases) {
708 inode->i_mode |= S_IWUSR;
709 inode->i_op = &openprom_alias_inode_operations;
710 } else
711 inode->i_op = proc_openprom_iops;
712 inode->i_nlink = 2;
713 break;
714 case OPFSL_NODENUM:
715 inode->i_mode = S_IFREG | S_IRUGO;
716 inode->i_op = &openpromfs_nodenum_inode_ops;
717 inode->i_nlink = 1;
718 inode->u.generic_ip = (void *)(long)(n);
719 break;
720 case OPFSL_PROPERTY:
721 if ((dirnode == options) && (len == 17)
722 && !strncmp (name, "security-password", 17))
723 inode->i_mode = S_IFREG | S_IRUSR | S_IWUSR;
724 else {
725 inode->i_mode = S_IFREG | S_IRUGO;
726 if (dirnode == options || dirnode == aliases) {
727 if (len != 4 || strncmp (name, "name", 4))
728 inode->i_mode |= S_IWUSR;
729 }
730 }
731 inode->i_op = &openpromfs_prop_inode_ops;
732 inode->i_nlink = 1;
733 if (inode->i_size < 0)
734 inode->i_size = 0;
735 inode->u.generic_ip = (void *)(long)(((u16)dirnode) |
736 (((u16)(ino - NODEP2INO(NODE(dir->i_ino).first_prop) - 1)) << 16));
737 break;
738 case OPFSL_DEVICE:
739 inode->i_mode = d->mode;
740 inode->i_op = &chrdev_inode_operations;
741 inode->i_nlink = 1;
742 inode->i_rdev = d->rdev;
743 break;
744 }
745 d_add(dentry, inode);
746 return 0;
747 }
748
749 static int openpromfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
750 {
751 struct inode *inode = filp->f_dentry->d_inode;
752 unsigned int ino;
753 u32 n;
754 int i, j;
755 char buffer[128];
756 u16 node;
757 char *p;
758 struct openpromfs_dev *d;
759 char buffer2[64];
760
761 if (!inode || !S_ISDIR (inode->i_mode)) return -ENOTDIR;
762 ino = inode->i_ino;
763 i = filp->f_pos;
764 switch (i) {
765 case 0:
766 if (filldir(dirent, ".", 1, i, ino) < 0) return 0;
767 i++;
768 filp->f_pos++;
769 /* fall thru */
770 case 1:
771 if (filldir(dirent, "..", 2, i,
772 (NODE(ino).parent == 0xffff) ?
773 PROC_ROOT_INO : NODE2INO(NODE(ino).parent)) < 0)
774 return 0;
775 i++;
776 filp->f_pos++;
777 /* fall thru */
778 default:
779 i -= 2;
780 node = NODE(ino).child;
781 while (i && node != 0xffff) {
782 node = nodes[node].next;
783 i--;
784 }
785 while (node != 0xffff) {
786 if (prom_getname (nodes[node].node, buffer, 128) < 0)
787 return 0;
788 if (filldir(dirent, buffer, strlen(buffer),
789 filp->f_pos, NODE2INO(node)) < 0)
790 return 0;
791 filp->f_pos++;
792 node = nodes[node].next;
793 }
794 j = NODEP2INO(NODE(ino).first_prop);
795 if (!i) {
796 if (filldir(dirent, ".node", 5, filp->f_pos, j) < 0)
797 return 0;
798 filp->f_pos++;
799 } else
800 i--;
801 n = NODE(ino).node;
802 if (ino == PROC_OPENPROM_FIRST + aliases) {
803 for (j++; i < aliases_nodes; i++, j++) {
804 if (alias_names [i]) {
805 if (filldir (dirent, alias_names [i],
806 strlen (alias_names [i]),
807 filp->f_pos, j) < 0) return 0;
808 filp->f_pos++;
809 }
810 }
811 } else {
812 for (p = prom_firstprop (n, buffer2);
813 p && *p;
814 p = prom_nextprop (n, p, buffer2)) {
815 j++;
816 if (i) i--;
817 else {
818 if (filldir(dirent, p, strlen(p),
819 filp->f_pos, j) < 0)
820 return 0;
821 filp->f_pos++;
822 }
823 }
824 }
825 for (d = *devices; d; d = d->next) {
826 if (d->node == n) {
827 if (i) i--;
828 else {
829 if (filldir(dirent, d->name,
830 strlen(d->name),
831 filp->f_pos, d->inode) < 0)
832 return 0;
833 filp->f_pos++;
834 }
835 }
836 }
837 }
838 return 0;
839 }
840
841 static int openpromfs_create (struct inode *dir, struct dentry *dentry, int mode)
842 {
843 char *p;
844 struct inode *inode;
845
846 if (!dir)
847 return -ENOENT;
848 if (dentry->d_name.len > 256)
849 return -EINVAL;
850 if (aliases_nodes == ALIASES_NNODES)
851 return -EIO;
852 p = kmalloc (dentry->d_name.len + 1, GFP_KERNEL);
853 if (!p)
854 return -ENOMEM;
855 strncpy (p, dentry->d_name.name, dentry->d_name.len);
856 p [dentry->d_name.len] = 0;
857 alias_names [aliases_nodes++] = p;
858 inode = proc_get_inode (dir->i_sb,
859 NODEP2INO(NODE(dir->i_ino).first_prop)
860 + aliases_nodes, 0);
861 if (!inode)
862 return -EINVAL;
863 inode->i_mode = S_IFREG | S_IRUGO | S_IWUSR;
864 inode->i_op = &openpromfs_prop_inode_ops;
865 inode->i_nlink = 1;
866 if (inode->i_size < 0) inode->i_size = 0;
867 inode->u.generic_ip = (void *)(long)(((u16)aliases) |
868 (((u16)(aliases_nodes - 1)) << 16));
869 d_instantiate(dentry, inode);
870 return 0;
871 }
872
873 static int openpromfs_unlink (struct inode *dir, struct dentry *dentry)
874 {
875 unsigned int len;
876 char *p;
877 const char *name;
878 int i;
879
880 name = dentry->d_name.name;
881 len = dentry->d_name.len;
882 for (i = 0; i < aliases_nodes; i++)
883 if ((strlen (alias_names [i]) == len)
884 && !strncmp (name, alias_names[i], len)) {
885 char buffer[512];
886
887 p = alias_names [i];
888 alias_names [i] = NULL;
889 kfree (p);
890 strcpy (buffer, "nvunalias ");
891 memcpy (buffer + 10, name, len);
892 buffer [10 + len] = 0;
893 prom_feval (buffer);
894 }
895 d_delete(dentry);
896 return 0;
897 }
898
899 /* {{{ init section */
900 #ifndef MODULE
901 __initfunc(static int check_space (u16 n))
902 #else
903 static int check_space (u16 n)
904 #endif
905 {
906 unsigned long pages;
907
908 if ((1 << alloced) * PAGE_SIZE < (n + 2) * sizeof(openpromfs_node)) {
909 pages = __get_free_pages (GFP_KERNEL, alloced + 1);
910 if (!pages)
911 return -1;
912
913 if (nodes) {
914 memcpy ((char *)pages, (char *)nodes,
915 (1 << alloced) * PAGE_SIZE);
916 free_pages ((unsigned long)nodes, alloced);
917 }
918 alloced++;
919 nodes = (openpromfs_node *)pages;
920 }
921 return 0;
922 }
923
924 #ifndef MODULE
925 __initfunc(static u16 get_nodes (u16 parent, u32 node))
926 #else
927 static u16 get_nodes (u16 parent, u32 node)
928 #endif
929 {
930 char *p;
931 u16 n = last_node++, i;
932 char buffer[64];
933
934 if (check_space (n) < 0)
935 return 0xffff;
936 nodes[n].parent = parent;
937 nodes[n].node = node;
938 nodes[n].next = 0xffff;
939 nodes[n].child = 0xffff;
940 nodes[n].first_prop = first_prop++;
941 if (!parent) {
942 char buffer[8];
943 int j;
944
945 if ((j = prom_getproperty (node, "name", buffer, 8)) >= 0) {
946 buffer[j] = 0;
947 if (!strcmp (buffer, "options"))
948 options = n;
949 else if (!strcmp (buffer, "aliases"))
950 aliases = n;
951 }
952 }
953 if (n != aliases)
954 for (p = prom_firstprop (node, buffer);
955 p && p != (char *)-1 && *p;
956 p = prom_nextprop (node, p, buffer))
957 first_prop++;
958 else {
959 char *q;
960 for (p = prom_firstprop (node, buffer);
961 p && p != (char *)-1 && *p;
962 p = prom_nextprop (node, p, buffer)) {
963 if (aliases_nodes == ALIASES_NNODES)
964 break;
965 for (i = 0; i < aliases_nodes; i++)
966 if (!strcmp (p, alias_names [i]))
967 break;
968 if (i < aliases_nodes)
969 continue;
970 q = kmalloc (strlen (p) + 1, GFP_KERNEL);
971 if (!q)
972 return 0xffff;
973 strcpy (q, p);
974 alias_names [aliases_nodes++] = q;
975 }
976 first_prop += ALIASES_NNODES;
977 }
978 node = prom_getchild (node);
979 if (node) {
980 parent = get_nodes (n, node);
981 if (parent == 0xffff)
982 return 0xffff;
983 nodes[n].child = parent;
984 while ((node = prom_getsibling (node)) != 0) {
985 i = get_nodes (n, node);
986 if (i == 0xffff)
987 return 0xffff;
988 nodes[parent].next = i;
989 parent = i;
990 }
991 }
992 return n;
993 }
994
995
996 #ifdef MODULE
997 void openpromfs_use (struct inode *inode, int inc)
998 {
999 static int root_fresh = 1;
1000 static int dec_first = 1;
1001 #ifdef OPENPROM_DEBUGGING
1002 static int usec = 0;
1003
1004 if (inc) {
1005 if (inode->i_count == 1)
1006 usec++;
1007 else if (root_fresh && inode->i_ino == PROC_OPENPROM_FIRST) {
1008 root_fresh = 0;
1009 usec++;
1010 }
1011 } else {
1012 if (inode->i_ino == PROC_OPENPROM_FIRST)
1013 root_fresh = 0;
1014 if (!dec_first)
1015 usec--;
1016 }
1017 printk ("openpromfs_use: %d %d %d %d\n",
1018 inode->i_ino, inc, usec, inode->i_count);
1019 #else
1020 if (inc) {
1021 if (inode->i_count == 1)
1022 MOD_INC_USE_COUNT;
1023 else if (root_fresh && inode->i_ino == PROC_OPENPROM_FIRST) {
1024 root_fresh = 0;
1025 MOD_INC_USE_COUNT;
1026 }
1027 } else {
1028 if (inode->i_ino == PROC_OPENPROM_FIRST)
1029 root_fresh = 0;
1030 if (!dec_first)
1031 MOD_DEC_USE_COUNT;
1032 }
1033 #endif
1034 dec_first = 0;
1035 }
1036
1037 #else
1038 #define openpromfs_use 0
1039 #endif
1040
1041 #ifndef MODULE
1042 #define RET(x)
1043 __initfunc(void openpromfs_init (void))
1044 #else
1045
1046 EXPORT_NO_SYMBOLS;
1047
1048 #define RET(x) -x
1049 int init_module (void)
1050 #endif
1051 {
1052 nodes = (openpromfs_node *)__get_free_pages(GFP_KERNEL, 0);
1053 if (!nodes) {
1054 printk (KERN_WARNING "/proc/openprom: can't get free page\n");
1055 return RET(EIO);
1056 }
1057 if (get_nodes (0xffff, prom_root_node) == 0xffff) {
1058 printk (KERN_WARNING "/proc/openprom: couldn't setup tree\n");
1059 return RET(EIO);
1060 }
1061 nodes[last_node].first_prop = first_prop;
1062 proc_openprom_iops = proc_openprom_register (openpromfs_readdir,
1063 openpromfs_lookup,
1064 openpromfs_use,
1065 &devices);
1066 return RET(0);
1067 }
1068
1069 #ifdef MODULE
1070 void cleanup_module (void)
1071 {
1072 int i;
1073 proc_openprom_deregister ();
1074 free_pages ((unsigned long)nodes, alloced);
1075 for (i = 0; i < aliases_nodes; i++)
1076 if (alias_names [i])
1077 kfree (alias_names [i]);
1078 nodes = NULL;
1079 }
1080 #endif
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux