home *** CD-ROM | disk | FTP | other *** search
/ Chip: Linux Special / CorelLinux_CHIP.iso / live / usr / include / linux / kerneld.h
Encoding:
C/C++ Source or Header  |  1998-10-18  |  5.0 KB  |  186 lines
  1. #ifndef _LINUX_KERNELD_H
  2. #define _LINUX_KERNELD_H
  3.  
  4. #define KERNELD_SYSTEM 1
  5. #define KERNELD_REQUEST_MODULE 2 /* "insmod" */
  6. #define KERNELD_RELEASE_MODULE 3 /* "rmmod" */
  7. #define KERNELD_DELAYED_RELEASE_MODULE 4 /* "rmmod" */
  8. #define KERNELD_CANCEL_RELEASE_MODULE 5 /* "rmmod" */
  9. #define KERNELD_REQUEST_ROUTE 6 /* from net/ipv4/route.c */
  10. #define KERNELD_BLANKER 7 /* from drivers/char/console.c */
  11. #define KERNELD_PNP 8 /* from drivers/pnp/kerneld.c */
  12. #define KERNELD_GET_PERSIST 200 /* persistent module storage */
  13. #define KERNELD_SET_PERSIST 201 /* persistent module storage */
  14. #define KERNELD_ARP 256 /* from net/ipv4/arp.c */
  15.  
  16. /*
  17.  * Uncomment the following line for the new kerneld protocol
  18.  * This includes the pid of the kernel level requester into the kerneld header
  19.  */
  20. /*
  21. #define NEW_KERNELD_PROTOCOL
  22.  */
  23. #ifdef NEW_KERNELD_PROTOCOL
  24. #define OLDIPC_KERNELD 00040000   /* use the kerneld message channel */
  25. #define IPC_KERNELD 00140000   /* use the kerneld message channel, new protocol */
  26. #define KDHDR (sizeof(long) + sizeof(short) + sizeof(short))
  27. #define NULL_KDHDR 0, 2, 0
  28. #else
  29. #define IPC_KERNELD 00040000   /* use the kerneld message channel */
  30. #define KDHDR (sizeof(long))
  31. #define NULL_KDHDR 0
  32. #endif
  33. #define KERNELD_MAXCMD 0x7ffeffff
  34. #define KERNELD_MINSEQ 0x7fff0000 /* "commands" legal up to 0x7ffeffff */
  35. #define KERNELD_WAIT 0x80000000
  36. #define KERNELD_NOWAIT 0
  37.  
  38. struct kerneld_msg {
  39.     long mtype;
  40.     long id;
  41. #ifdef NEW_KERNELD_PROTOCOL
  42.     short version;
  43.     short pid;
  44. #endif
  45. #ifdef __KERNEL__
  46.     char *text;
  47. #else
  48.     char text[1];
  49. #endif /* __KERNEL__ */
  50. };
  51.  
  52. struct __persist {
  53.        int keylen;
  54.        int arglen;
  55.        char arr[0];
  56. };
  57.  
  58. #ifdef __KERNEL__
  59. #include <linux/malloc.h>
  60. extern int kerneld_send(int msgtype, int ret_size, int msgsz,
  61.         const char *text, const char *ret_val);
  62.  
  63. /*
  64.  * Request that a module should be loaded.
  65.  * Wait for the exit status from insmod/modprobe.
  66.  * If it fails, it fails... at least we tried...
  67.  */
  68. static inline int request_module(const char *name)
  69. {
  70.     return kerneld_send(KERNELD_REQUEST_MODULE,
  71.             0 | KERNELD_WAIT,
  72.             strlen(name), name, NULL);
  73. }
  74.  
  75. /*
  76.  * Request the removal of a module, maybe don't wait for it.
  77.  * It doesn't matter if the removal fails, now does it?
  78.  */
  79. static inline int release_module(const char *name, int waitflag)
  80. {
  81.     return kerneld_send(KERNELD_RELEASE_MODULE,
  82.             0 | (waitflag?KERNELD_WAIT:KERNELD_NOWAIT),
  83.             strlen(name), name, NULL);
  84. }
  85.  
  86. /*
  87.  * Request a delayed removal of a module, but don't wait for it.
  88.  * The delay is done by kerneld (default: 60 seconds)
  89.  */
  90. static inline int delayed_release_module(const char *name)
  91. {
  92.     return kerneld_send(KERNELD_DELAYED_RELEASE_MODULE,
  93.             0 | KERNELD_NOWAIT,
  94.             strlen(name), name, NULL);
  95. }
  96.  
  97. /*
  98.  * Attempt to cancel a previous request for removal of a module,
  99.  * but don't wait for it.
  100.  * This call can be made if the kernel wants to prevent a delayed
  101.  * unloading of a module.
  102.  */
  103. static inline int cancel_release_module(const char *name)
  104. {
  105.     return kerneld_send(KERNELD_CANCEL_RELEASE_MODULE,
  106.             0 | KERNELD_NOWAIT,
  107.             strlen(name), name, NULL);
  108. }
  109.  
  110. /*
  111.  * Perform an "inverted" system call, maybe return the exit status
  112.  */
  113. static inline int ksystem(const char *cmd, int waitflag)
  114. {
  115.     return kerneld_send(KERNELD_SYSTEM,
  116.             0 | (waitflag?KERNELD_WAIT:KERNELD_NOWAIT),
  117.             strlen(cmd), cmd, NULL);
  118. }
  119.  
  120. /*
  121.  * Try to create a route, possibly by opening a ppp-connection
  122.  */
  123. static inline int kerneld_route(const char *ip_route)
  124. {
  125.     return kerneld_send(KERNELD_REQUEST_ROUTE,
  126.             0 | KERNELD_WAIT,
  127.             strlen(ip_route), ip_route, NULL);
  128. }
  129.  
  130. /*
  131.  * Handle an external screen blanker
  132.  */
  133. static inline int kerneld_blanker(int on_off) /* 0 => "off", else "on" */
  134. {
  135.     return kerneld_send(KERNELD_BLANKER,
  136.             0 | (on_off?KERNELD_NOWAIT:KERNELD_WAIT),
  137.             strlen(on_off?"on":"off"), on_off?"on":"off", NULL);
  138. }
  139.  
  140.  
  141. /*
  142.  * Persistent storage for modules
  143.  *
  144.  * Usage:
  145.  *     int get_persist("a key", &value, sizeof(value));
  146.  *             Returns > 0 on success (return value == returned size)
  147.  *
  148.  *     int set_persist("a key", &value, sizeof(value));
  149.  *             Returns < 0 on failure
  150.  *
  151.  * To remove an entry, use: "set_persist("a key", NULL, 0);"
  152.  */
  153.  
  154. static inline int set_persist(char *key, void *value, size_t length)
  155. {
  156.        struct __persist *p;
  157.        int keylen = strlen(key) + 1;
  158.        int structsize = keylen + length + sizeof(struct __persist);
  159.        int status;
  160.  
  161.        if ((p = (struct __persist *)kmalloc(structsize, GFP_ATOMIC)) == NULL)
  162.                return -ENOMEM;
  163.        strcpy(p->arr, key);
  164.        p->keylen = keylen;
  165.        p->arglen = length;
  166.        if (length)
  167.                memcpy(p->arr + keylen, value, length);
  168.  
  169.        status = kerneld_send(KERNELD_SET_PERSIST,
  170.                        0 | KERNELD_NOWAIT,
  171.                        structsize, (char *)p, NULL);
  172.  
  173.        kfree(p);
  174.        return status;
  175. }
  176.  
  177. static inline int get_persist(char *key, void *value, size_t length)
  178. {
  179.        return kerneld_send(KERNELD_GET_PERSIST,
  180.                        length | KERNELD_WAIT,
  181.                        strlen(key), key, value);
  182. }
  183.  
  184. #endif /* __KERNEL__ */
  185. #endif
  186.