Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/misc/ibmasm/ibmasmfs.c

  1 /*
  2  * IBM ASM Service Processor Device Driver
  3  *
  4  * This program is free software; you can redistribute it and/or modify
  5  * it under the terms of the GNU General Public License as published by
  6  * the Free Software Foundation; either version 2 of the License, or
  7  * (at your option) any later version.
  8  *
  9  * This program is distributed in the hope that it will be useful,
 10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12  * GNU General Public License for more details.
 13  *
 14  * You should have received a copy of the GNU General Public License
 15  * along with this program; if not, write to the Free Software
 16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 17  *
 18  * Copyright (C) IBM Corporation, 2004
 19  *
 20  * Author: Max Asböck <amax@us.ibm.com>
 21  *
 22  */
 23 
 24 /*
 25  * Parts of this code are based on an article by Jonathan Corbet
 26  * that appeared in Linux Weekly News.
 27  */
 28 
 29 
 30 /*
 31  * The IBMASM file virtual filesystem. It creates the following hierarchy
 32  * dynamically when mounted from user space:
 33  *
 34  *    /ibmasm
 35  *    |-- 0
 36  *    |   |-- command
 37  *    |   |-- event
 38  *    |   |-- reverse_heartbeat
 39  *    |   `-- remote_video
 40  *    |       |-- depth
 41  *    |       |-- height
 42  *    |       `-- width
 43  *    .
 44  *    .
 45  *    .
 46  *    `-- n
 47  *        |-- command
 48  *        |-- event
 49  *        |-- reverse_heartbeat
 50  *        `-- remote_video
 51  *            |-- depth
 52  *            |-- height
 53  *            `-- width
 54  *
 55  * For each service processor the following files are created:
 56  *
 57  * command: execute dot commands
 58  *      write: execute a dot command on the service processor
 59  *      read: return the result of a previously executed dot command
 60  *
 61  * events: listen for service processor events
 62  *      read: sleep (interruptible) until an event occurs
 63  *      write: wakeup sleeping event listener
 64  *
 65  * reverse_heartbeat: send a heartbeat to the service processor
 66  *      read: sleep (interruptible) until the reverse heartbeat fails
 67  *      write: wakeup sleeping heartbeat listener
 68  *
 69  * remote_video/width
 70  * remote_video/height
 71  * remote_video/width: control remote display settings
 72  *      write: set value
 73  *      read: read value
 74  */
 75 
 76 #include <linux/fs.h>
 77 #include <linux/pagemap.h>
 78 #include <linux/slab.h>
 79 #include <asm/uaccess.h>
 80 #include <asm/io.h>
 81 #include "ibmasm.h"
 82 #include "remote.h"
 83 #include "dot_command.h"
 84 
 85 #define IBMASMFS_MAGIC 0x66726f67
 86 
 87 static LIST_HEAD(service_processors);
 88 
 89 static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode);
 90 static void ibmasmfs_create_files (struct super_block *sb);
 91 static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent);
 92 
 93 
 94 static struct dentry *ibmasmfs_mount(struct file_system_type *fst,
 95                         int flags, const char *name, void *data)
 96 {
 97         return mount_single(fst, flags, data, ibmasmfs_fill_super);
 98 }
 99 
100 static const struct super_operations ibmasmfs_s_ops = {
101         .statfs         = simple_statfs,
102         .drop_inode     = generic_delete_inode,
103 };
104 
105 static const struct file_operations *ibmasmfs_dir_ops = &simple_dir_operations;
106 
107 static struct file_system_type ibmasmfs_type = {
108         .owner          = THIS_MODULE,
109         .name           = "ibmasmfs",
110         .mount          = ibmasmfs_mount,
111         .kill_sb        = kill_litter_super,
112 };
113 MODULE_ALIAS_FS("ibmasmfs");
114 
115 static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent)
116 {
117         struct inode *root;
118 
119         sb->s_blocksize = PAGE_CACHE_SIZE;
120         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
121         sb->s_magic = IBMASMFS_MAGIC;
122         sb->s_op = &ibmasmfs_s_ops;
123         sb->s_time_gran = 1;
124 
125         root = ibmasmfs_make_inode (sb, S_IFDIR | 0500);
126         if (!root)
127                 return -ENOMEM;
128 
129         root->i_op = &simple_dir_inode_operations;
130         root->i_fop = ibmasmfs_dir_ops;
131 
132         sb->s_root = d_make_root(root);
133         if (!sb->s_root)
134                 return -ENOMEM;
135 
136         ibmasmfs_create_files(sb);
137         return 0;
138 }
139 
140 static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode)
141 {
142         struct inode *ret = new_inode(sb);
143 
144         if (ret) {
145                 ret->i_ino = get_next_ino();
146                 ret->i_mode = mode;
147                 ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
148         }
149         return ret;
150 }
151 
152 static struct dentry *ibmasmfs_create_file(struct dentry *parent,
153                         const char *name,
154                         const struct file_operations *fops,
155                         void *data,
156                         int mode)
157 {
158         struct dentry *dentry;
159         struct inode *inode;
160 
161         dentry = d_alloc_name(parent, name);
162         if (!dentry)
163                 return NULL;
164 
165         inode = ibmasmfs_make_inode(parent->d_sb, S_IFREG | mode);
166         if (!inode) {
167                 dput(dentry);
168                 return NULL;
169         }
170 
171         inode->i_fop = fops;
172         inode->i_private = data;
173 
174         d_add(dentry, inode);
175         return dentry;
176 }
177 
178 static struct dentry *ibmasmfs_create_dir(struct dentry *parent,
179                                 const char *name)
180 {
181         struct dentry *dentry;
182         struct inode *inode;
183 
184         dentry = d_alloc_name(parent, name);
185         if (!dentry)
186                 return NULL;
187 
188         inode = ibmasmfs_make_inode(parent->d_sb, S_IFDIR | 0500);
189         if (!inode) {
190                 dput(dentry);
191                 return NULL;
192         }
193 
194         inode->i_op = &simple_dir_inode_operations;
195         inode->i_fop = ibmasmfs_dir_ops;
196 
197         d_add(dentry, inode);
198         return dentry;
199 }
200 
201 int ibmasmfs_register(void)
202 {
203         return register_filesystem(&ibmasmfs_type);
204 }
205 
206 void ibmasmfs_unregister(void)
207 {
208         unregister_filesystem(&ibmasmfs_type);
209 }
210 
211 void ibmasmfs_add_sp(struct service_processor *sp)
212 {
213         list_add(&sp->node, &service_processors);
214 }
215 
216 /* struct to save state between command file operations */
217 struct ibmasmfs_command_data {
218         struct service_processor        *sp;
219         struct command                  *command;
220 };
221 
222 /* struct to save state between event file operations */
223 struct ibmasmfs_event_data {
224         struct service_processor        *sp;
225         struct event_reader             reader;
226         int                             active;
227 };
228 
229 /* struct to save state between reverse heartbeat file operations */
230 struct ibmasmfs_heartbeat_data {
231         struct service_processor        *sp;
232         struct reverse_heartbeat        heartbeat;
233         int                             active;
234 };
235 
236 static int command_file_open(struct inode *inode, struct file *file)
237 {
238         struct ibmasmfs_command_data *command_data;
239 
240         if (!inode->i_private)
241                 return -ENODEV;
242 
243         command_data = kmalloc(sizeof(struct ibmasmfs_command_data), GFP_KERNEL);
244         if (!command_data)
245                 return -ENOMEM;
246 
247         command_data->command = NULL;
248         command_data->sp = inode->i_private;
249         file->private_data = command_data;
250         return 0;
251 }
252 
253 static int command_file_close(struct inode *inode, struct file *file)
254 {
255         struct ibmasmfs_command_data *command_data = file->private_data;
256 
257         if (command_data->command)
258                 command_put(command_data->command);
259 
260         kfree(command_data);
261         return 0;
262 }
263 
264 static ssize_t command_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
265 {
266         struct ibmasmfs_command_data *command_data = file->private_data;
267         struct command *cmd;
268         int len;
269         unsigned long flags;
270 
271         if (*offset < 0)
272                 return -EINVAL;
273         if (count == 0 || count > IBMASM_CMD_MAX_BUFFER_SIZE)
274                 return 0;
275         if (*offset != 0)
276                 return 0;
277 
278         spin_lock_irqsave(&command_data->sp->lock, flags);
279         cmd = command_data->command;
280         if (cmd == NULL) {
281                 spin_unlock_irqrestore(&command_data->sp->lock, flags);
282                 return 0;
283         }
284         command_data->command = NULL;
285         spin_unlock_irqrestore(&command_data->sp->lock, flags);
286 
287         if (cmd->status != IBMASM_CMD_COMPLETE) {
288                 command_put(cmd);
289                 return -EIO;
290         }
291         len = min(count, cmd->buffer_size);
292         if (copy_to_user(buf, cmd->buffer, len)) {
293                 command_put(cmd);
294                 return -EFAULT;
295         }
296         command_put(cmd);
297 
298         return len;
299 }
300 
301 static ssize_t command_file_write(struct file *file, const char __user *ubuff, size_t count, loff_t *offset)
302 {
303         struct ibmasmfs_command_data *command_data = file->private_data;
304         struct command *cmd;
305         unsigned long flags;
306 
307         if (*offset < 0)
308                 return -EINVAL;
309         if (count == 0 || count > IBMASM_CMD_MAX_BUFFER_SIZE)
310                 return 0;
311         if (*offset != 0)
312                 return 0;
313 
314         /* commands are executed sequentially, only one command at a time */
315         if (command_data->command)
316                 return -EAGAIN;
317 
318         cmd = ibmasm_new_command(command_data->sp, count);
319         if (!cmd)
320                 return -ENOMEM;
321 
322         if (copy_from_user(cmd->buffer, ubuff, count)) {
323                 command_put(cmd);
324                 return -EFAULT;
325         }
326 
327         spin_lock_irqsave(&command_data->sp->lock, flags);
328         if (command_data->command) {
329                 spin_unlock_irqrestore(&command_data->sp->lock, flags);
330                 command_put(cmd);
331                 return -EAGAIN;
332         }
333         command_data->command = cmd;
334         spin_unlock_irqrestore(&command_data->sp->lock, flags);
335 
336         ibmasm_exec_command(command_data->sp, cmd);
337         ibmasm_wait_for_response(cmd, get_dot_command_timeout(cmd->buffer));
338 
339         return count;
340 }
341 
342 static int event_file_open(struct inode *inode, struct file *file)
343 {
344         struct ibmasmfs_event_data *event_data;
345         struct service_processor *sp;
346 
347         if (!inode->i_private)
348                 return -ENODEV;
349 
350         sp = inode->i_private;
351 
352         event_data = kmalloc(sizeof(struct ibmasmfs_event_data), GFP_KERNEL);
353         if (!event_data)
354                 return -ENOMEM;
355 
356         ibmasm_event_reader_register(sp, &event_data->reader);
357 
358         event_data->sp = sp;
359         event_data->active = 0;
360         file->private_data = event_data;
361         return 0;
362 }
363 
364 static int event_file_close(struct inode *inode, struct file *file)
365 {
366         struct ibmasmfs_event_data *event_data = file->private_data;
367 
368         ibmasm_event_reader_unregister(event_data->sp, &event_data->reader);
369         kfree(event_data);
370         return 0;
371 }
372 
373 static ssize_t event_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
374 {
375         struct ibmasmfs_event_data *event_data = file->private_data;
376         struct event_reader *reader = &event_data->reader;
377         struct service_processor *sp = event_data->sp;
378         int ret;
379         unsigned long flags;
380 
381         if (*offset < 0)
382                 return -EINVAL;
383         if (count == 0 || count > IBMASM_EVENT_MAX_SIZE)
384                 return 0;
385         if (*offset != 0)
386                 return 0;
387 
388         spin_lock_irqsave(&sp->lock, flags);
389         if (event_data->active) {
390                 spin_unlock_irqrestore(&sp->lock, flags);
391                 return -EBUSY;
392         }
393         event_data->active = 1;
394         spin_unlock_irqrestore(&sp->lock, flags);
395 
396         ret = ibmasm_get_next_event(sp, reader);
397         if (ret <= 0)
398                 goto out;
399 
400         if (count < reader->data_size) {
401                 ret = -EINVAL;
402                 goto out;
403         }
404 
405         if (copy_to_user(buf, reader->data, reader->data_size)) {
406                 ret = -EFAULT;
407                 goto out;
408         }
409         ret = reader->data_size;
410 
411 out:
412         event_data->active = 0;
413         return ret;
414 }
415 
416 static ssize_t event_file_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
417 {
418         struct ibmasmfs_event_data *event_data = file->private_data;
419 
420         if (*offset < 0)
421                 return -EINVAL;
422         if (count != 1)
423                 return 0;
424         if (*offset != 0)
425                 return 0;
426 
427         ibmasm_cancel_next_event(&event_data->reader);
428         return 0;
429 }
430 
431 static int r_heartbeat_file_open(struct inode *inode, struct file *file)
432 {
433         struct ibmasmfs_heartbeat_data *rhbeat;
434 
435         if (!inode->i_private)
436                 return -ENODEV;
437 
438         rhbeat = kmalloc(sizeof(struct ibmasmfs_heartbeat_data), GFP_KERNEL);
439         if (!rhbeat)
440                 return -ENOMEM;
441 
442         rhbeat->sp = inode->i_private;
443         rhbeat->active = 0;
444         ibmasm_init_reverse_heartbeat(rhbeat->sp, &rhbeat->heartbeat);
445         file->private_data = rhbeat;
446         return 0;
447 }
448 
449 static int r_heartbeat_file_close(struct inode *inode, struct file *file)
450 {
451         struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
452 
453         kfree(rhbeat);
454         return 0;
455 }
456 
457 static ssize_t r_heartbeat_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
458 {
459         struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
460         unsigned long flags;
461         int result;
462 
463         if (*offset < 0)
464                 return -EINVAL;
465         if (count == 0 || count > 1024)
466                 return 0;
467         if (*offset != 0)
468                 return 0;
469 
470         /* allow only one reverse heartbeat per process */
471         spin_lock_irqsave(&rhbeat->sp->lock, flags);
472         if (rhbeat->active) {
473                 spin_unlock_irqrestore(&rhbeat->sp->lock, flags);
474                 return -EBUSY;
475         }
476         rhbeat->active = 1;
477         spin_unlock_irqrestore(&rhbeat->sp->lock, flags);
478 
479         result = ibmasm_start_reverse_heartbeat(rhbeat->sp, &rhbeat->heartbeat);
480         rhbeat->active = 0;
481 
482         return result;
483 }
484 
485 static ssize_t r_heartbeat_file_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
486 {
487         struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
488 
489         if (*offset < 0)
490                 return -EINVAL;
491         if (count != 1)
492                 return 0;
493         if (*offset != 0)
494                 return 0;
495 
496         if (rhbeat->active)
497                 ibmasm_stop_reverse_heartbeat(&rhbeat->heartbeat);
498 
499         return 1;
500 }
501 
502 static int remote_settings_file_close(struct inode *inode, struct file *file)
503 {
504         return 0;
505 }
506 
507 static ssize_t remote_settings_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
508 {
509         void __iomem *address = (void __iomem *)file->private_data;
510         unsigned char *page;
511         int retval;
512         int len = 0;
513         unsigned int value;
514 
515         if (*offset < 0)
516                 return -EINVAL;
517         if (count == 0 || count > 1024)
518                 return 0;
519         if (*offset != 0)
520                 return 0;
521 
522         page = (unsigned char *)__get_free_page(GFP_KERNEL);
523         if (!page)
524                 return -ENOMEM;
525 
526         value = readl(address);
527         len = sprintf(page, "%d\n", value);
528 
529         if (copy_to_user(buf, page, len)) {
530                 retval = -EFAULT;
531                 goto exit;
532         }
533         *offset += len;
534         retval = len;
535 
536 exit:
537         free_page((unsigned long)page);
538         return retval;
539 }
540 
541 static ssize_t remote_settings_file_write(struct file *file, const char __user *ubuff, size_t count, loff_t *offset)
542 {
543         void __iomem *address = (void __iomem *)file->private_data;
544         char *buff;
545         unsigned int value;
546 
547         if (*offset < 0)
548                 return -EINVAL;
549         if (count == 0 || count > 1024)
550                 return 0;
551         if (*offset != 0)
552                 return 0;
553 
554         buff = kzalloc (count + 1, GFP_KERNEL);
555         if (!buff)
556                 return -ENOMEM;
557 
558 
559         if (copy_from_user(buff, ubuff, count)) {
560                 kfree(buff);
561                 return -EFAULT;
562         }
563 
564         value = simple_strtoul(buff, NULL, 10);
565         writel(value, address);
566         kfree(buff);
567 
568         return count;
569 }
570 
571 static const struct file_operations command_fops = {
572         .open =         command_file_open,
573         .release =      command_file_close,
574         .read =         command_file_read,
575         .write =        command_file_write,
576         .llseek =       generic_file_llseek,
577 };
578 
579 static const struct file_operations event_fops = {
580         .open =         event_file_open,
581         .release =      event_file_close,
582         .read =         event_file_read,
583         .write =        event_file_write,
584         .llseek =       generic_file_llseek,
585 };
586 
587 static const struct file_operations r_heartbeat_fops = {
588         .open =         r_heartbeat_file_open,
589         .release =      r_heartbeat_file_close,
590         .read =         r_heartbeat_file_read,
591         .write =        r_heartbeat_file_write,
592         .llseek =       generic_file_llseek,
593 };
594 
595 static const struct file_operations remote_settings_fops = {
596         .open =         simple_open,
597         .release =      remote_settings_file_close,
598         .read =         remote_settings_file_read,
599         .write =        remote_settings_file_write,
600         .llseek =       generic_file_llseek,
601 };
602 
603 
604 static void ibmasmfs_create_files (struct super_block *sb)
605 {
606         struct list_head *entry;
607         struct service_processor *sp;
608 
609         list_for_each(entry, &service_processors) {
610                 struct dentry *dir;
611                 struct dentry *remote_dir;
612                 sp = list_entry(entry, struct service_processor, node);
613                 dir = ibmasmfs_create_dir(sb->s_root, sp->dirname);
614                 if (!dir)
615                         continue;
616 
617                 ibmasmfs_create_file(dir, "command", &command_fops, sp, S_IRUSR|S_IWUSR);
618                 ibmasmfs_create_file(dir, "event", &event_fops, sp, S_IRUSR|S_IWUSR);
619                 ibmasmfs_create_file(dir, "reverse_heartbeat", &r_heartbeat_fops, sp, S_IRUSR|S_IWUSR);
620 
621                 remote_dir = ibmasmfs_create_dir(dir, "remote_video");
622                 if (!remote_dir)
623                         continue;
624 
625                 ibmasmfs_create_file(remote_dir, "width", &remote_settings_fops, (void *)display_width(sp), S_IRUSR|S_IWUSR);
626                 ibmasmfs_create_file(remote_dir, "height", &remote_settings_fops, (void *)display_height(sp), S_IRUSR|S_IWUSR);
627                 ibmasmfs_create_file(remote_dir, "depth", &remote_settings_fops, (void *)display_depth(sp), S_IRUSR|S_IWUSR);
628         }
629 }
630 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us