LCOV - code coverage report
Current view: top level - lkbce/include/linux - kmod.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2017-01-25 Functions: 1 1 100.0 %

          Line data    Source code
       1             : #ifndef __LINUX_KMOD_H__
       2             : #define __LINUX_KMOD_H__
       3             : 
       4             : /*
       5             :  *      include/linux/kmod.h
       6             :  *
       7             :  *      This program is free software; you can redistribute it and/or modify
       8             :  *      it under the terms of the GNU General Public License as published by
       9             :  *      the Free Software Foundation; either version 2 of the License, or
      10             :  *      (at your option) any later version.
      11             :  *
      12             :  *      This program is distributed in the hope that it will be useful,
      13             :  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :  *      GNU General Public License for more details.
      16             :  *
      17             :  *      You should have received a copy of the GNU General Public License
      18             :  *      along with this program; if not, write to the Free Software
      19             :  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
      20             :  */
      21             : 
      22             : #include <linux/gfp.h>
      23             : #include <linux/stddef.h>
      24             : #include <linux/errno.h>
      25             : #include <linux/compiler.h>
      26             : 
      27             : #define KMOD_PATH_LEN 256
      28             : 
      29             : #ifdef CONFIG_MODULES
      30             : /* modprobe exit status on success, -ve on error.  Return value
      31             :  * usually useless though. */
      32             : extern int __request_module(bool wait, const char *name, ...) \
      33             :         __attribute__((format(printf, 2, 3)));
      34             : #define request_module(mod...) __request_module(true, mod)
      35             : #define request_module_nowait(mod...) __request_module(false, mod)
      36             : #define try_then_request_module(x, mod...) \
      37             :         ((x) ?: (__request_module(true, mod), (x)))
      38             : #else
      39           6 : static inline int request_module(const char *name, ...) { return -ENOSYS; }
      40             : static inline int request_module_nowait(const char *name, ...) { return -ENOSYS; }
      41             : #define try_then_request_module(x, mod...) (x)
      42             : #endif
      43             : 
      44             : 
      45             : struct key;
      46             : struct file;
      47             : struct subprocess_info;
      48             : 
      49             : /* Allocate a subprocess_info structure */
      50             : struct subprocess_info *call_usermodehelper_setup(char *path, char **argv,
      51             :                                                   char **envp, gfp_t gfp_mask);
      52             : 
      53             : /* Set various pieces of state into the subprocess_info structure */
      54             : void call_usermodehelper_setkeys(struct subprocess_info *info,
      55             :                                  struct key *session_keyring);
      56             : int call_usermodehelper_stdinpipe(struct subprocess_info *sub_info,
      57             :                                   struct file **filp);
      58             : void call_usermodehelper_setcleanup(struct subprocess_info *info,
      59             :                                     void (*cleanup)(char **argv, char **envp));
      60             : 
      61             : enum umh_wait {
      62             :         UMH_NO_WAIT = -1,       /* don't wait at all */
      63             :         UMH_WAIT_EXEC = 0,      /* wait for the exec, but not the process */
      64             :         UMH_WAIT_PROC = 1,      /* wait for the process to complete */
      65             : };
      66             : 
      67             : /* Actually execute the sub-process */
      68             : int call_usermodehelper_exec(struct subprocess_info *info, enum umh_wait wait);
      69             : 
      70             : /* Free the subprocess_info. This is only needed if you're not going
      71             :    to call call_usermodehelper_exec */
      72             : void call_usermodehelper_freeinfo(struct subprocess_info *info);
      73             : 
      74             : static inline int
      75             : call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)
      76             : {
      77             :         struct subprocess_info *info;
      78             :         gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL;
      79             : 
      80             :         info = call_usermodehelper_setup(path, argv, envp, gfp_mask);
      81             :         if (info == NULL)
      82             :                 return -ENOMEM;
      83             :         return call_usermodehelper_exec(info, wait);
      84             : }
      85             : 
      86             : static inline int
      87             : call_usermodehelper_keys(char *path, char **argv, char **envp,
      88             :                          struct key *session_keyring, enum umh_wait wait)
      89             : {
      90             :         struct subprocess_info *info;
      91             :         gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL;
      92             : 
      93             :         info = call_usermodehelper_setup(path, argv, envp, gfp_mask);
      94             :         if (info == NULL)
      95             :                 return -ENOMEM;
      96             : 
      97             :         call_usermodehelper_setkeys(info, session_keyring);
      98             :         return call_usermodehelper_exec(info, wait);
      99             : }
     100             : 
     101             : extern void usermodehelper_init(void);
     102             : 
     103             : struct file;
     104             : extern int call_usermodehelper_pipe(char *path, char *argv[], char *envp[],
     105             :                                     struct file **filp);
     106             : 
     107             : extern int usermodehelper_disable(void);
     108             : extern void usermodehelper_enable(void);
     109             : 
     110             : #endif /* __LINUX_KMOD_H__ */

Generated by: LCOV version 1.10