LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    init_module

    
    
    

    SYNOPSIS

           int init_module(void *module_image, unsigned long len,
                           const char *param_values);
    
           int finit_module(int fd, const char *param_values,
                            int flags);
    
           Note: There are no glibc wrappers for these system calls; see NOTES.
    
    
    

    DESCRIPTION

           init_module() loads an ELF image into kernel space, performs any neces-
           sary symbol relocations, initializes module parameters to  values  pro-
           vided  by  the  caller, and then runs the module's init function.  This
           system call requires privilege.
    
           The module_image argument points to  a  buffer  containing  the  binary
           image  to be loaded; len specifies the size of that buffer.  The module
           image should be a valid ELF image, built for the running kernel.
    
           The param_values argument is a string containing space-delimited speci-
           fications  of the values for module parameters (defined inside the mod-
           ule using module_param() and module_param_array()).  The kernel  parses
           this  string  and  initializes  the  specified parameters.  Each of the
           parameter specifications has the form:
    
                   name[=value[,value...]]
    
           The parameter name is one of those defined within the module using mod-
           ule_param()  (see  the  Linux  kernel  source  file  include/linux/mod-
           uleparam.h).  The parameter value is optional in the case of  bool  and
           invbool  parameters.   Values  for  array parameters are specified as a
           comma-separated list.
    
       finit_module()
           The finit_module() system call is like  init_module(),  but  reads  the
           module to be loaded from the file descriptor fd.  It is useful when the
           authenticity of a kernel module can be determined from its location  in
           the  filesystem; in cases where that is possible, the overhead of using
           cryptographically signed modules to determine  the  authenticity  of  a
           module  can  be avoided.  The param_values argument is as for init_mod-
           ule().
    
           The flags argument modifies the operation of finit_module().  It  is  a
           bit  mask value created by ORing together zero or more of the following
           flags:
    
           MODULE_INIT_IGNORE_MODVERSIONS
                  Ignore symbol version hashes.
    
           MODULE_INIT_IGNORE_VERMAGIC
                  Ignore kernel version magic.
    
           flag indicates that the symbol version hashes are to  be  ignored.   If
           the  kernel  is  built  to permit forced loading (i.e., configured with
           CONFIG_MODULE_FORCE_LOAD), then loading  will  continue,  otherwise  it
           will fail with ENOEXEC as expected for malformed modules.
    
    
    

    RETURN VALUE

           On  success, these system calls return 0.  On error, -1 is returned and
           errno is set appropriately.
    
    
    

    ERRORS

           EBADMSG (since Linux 3.7)
                  Module signature is misformatted.
    
           EBUSY  Timeout while trying to resolve a symbol reference by this  mod-
                  ule.
    
           EFAULT An  address  argument referred to a location that is outside the
                  process's accessible address space.
    
           ENOKEY (since Linux 3.7)
                  Module signature is invalid or the kernel does not  have  a  key
                  for  this module.  This error is returned only if the kernel was
                  configured with CONFIG_MODULE_SIG_FORCE; if the kernel  was  not
                  configured  with this option, then an invalid or unsigned module
                  simply taints the kernel.
    
           ENOMEM Out of memory.
    
           EPERM  The caller was not privileged (did not have  the  CAP_SYS_MODULE
                  capability),  or  module loading is disabled (see /proc/sys/ker-
                  nel/modules_disabled in proc(5)).
    
           The following errors may additionally occur for init_module():
    
           EEXIST A module with this name is already loaded.
    
           EINVAL param_values is invalid, or some part of the ELF image  in  mod-
                  ule_image contains inconsistencies.
    
           ENOEXEC
                  The  binary  image supplied in module_image is not an ELF image,
                  or is an ELF image that is invalid or for a different  architec-
                  ture.
    
           The following errors may additionally occur for finit_module():
    
           EBADF  The file referred to by fd is not opened for reading.
    
           EFBIG  The file referred to by fd is too large.
    
           EINVAL flags is invalid.
    
           Glibc  does  not  provide  a  wrapper for these system calls; call them
           using syscall(2).
    
           Information about currently loaded modules can be found  in  /proc/mod-
           ules  and  in  the file trees under the per-module subdirectories under
           /sys/module.
    
           See the Linux kernel source file include/linux/module.h for some useful
           background information.
    
       Linux 2.4 and earlier
           In Linux 2.4 and earlier, the init_module() system call was rather dif-
           ferent:
    
               #include <linux/module.h>
    
               int init_module(const char *name, struct module *image);
    
           (User-space applications can detect which version of  init_module()  is
           available  by  calling  query_module();  the latter call fails with the
           error ENOSYS on Linux 2.6 and later.)
    
           The older version of the system call loads the relocated  module  image
           pointed  to by image into kernel space and runs the module's init func-
           tion.  The caller is responsible  for  providing  the  relocated  image
           (since Linux 2.6, the init_module() system call does the relocation).
    
           The module image begins with a module structure and is followed by code
           and data as appropriate.  Since Linux  2.2,  the  module  structure  is
           defined as follows:
    
               struct module {
                   unsigned long         size_of_struct;
                   struct module        *next;
                   const char           *name;
                   unsigned long         size;
                   long                  usecount;
                   unsigned long         flags;
                   unsigned int          nsyms;
                   unsigned int          ndeps;
                   struct module_symbol *syms;
                   struct module_ref    *deps;
                   struct module_ref    *refs;
                   int                 (*init)(void);
                   void                (*cleanup)(void);
                   const struct exception_table_entry *ex_table_start;
                   const struct exception_table_entry *ex_table_end;
               #ifdef __alpha__
                   unsigned long gp;
               #endif
               };
    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz