Remove unsafe try_module_get(THIS_MODULE)

This commit removes all instances of try_module_get(THIS_MODULE) and
corresponding module_put(THIS_MODULE) calls from example modules. This
pattern is considered unsafe because:
- The kernel automatically manages module reference counting during file
  operations
- Manual reference counting within a module's own code can lead to race
  conditions
- It is redundant and unnecessary for proper module operation

It also updates documentation to:
- Remove references to try_module_get/module_put functions
- Add note explaining why these functions should be avoided
- Keep only module_refcount() as a safe display function

Close #52

Author: jserv

examples/chardev.c

@@ -96,7 +96,6 @@ static int device_open(struct inode *inode, struct file *file)
         return -EBUSY;
 
     sprintf(msg, "I already told you %d times Hello world!\n", counter++);
-    try_module_get(THIS_MODULE);
 
     return 0;
 }
@@ -107,11 +106,6 @@ static int device_release(struct inode *inode, struct file *file)
     /* We're now ready for our next caller */
     atomic_set(&already_open, CDEV_NOT_USED);
 
-    /* Decrement the usage count, or else once you opened the file, you will
-     * never get rid of the module.
-     */
-    module_put(THIS_MODULE);
-
     return 0;
 }
 

examples/chardev2.c

@@ -40,15 +40,13 @@ static int device_open(struct inode *inode, struct file *file)
 {
     pr_info("device_open(%p)\n", file);
 
-    try_module_get(THIS_MODULE);
     return 0;
 }
 
 static int device_release(struct inode *inode, struct file *file)
 {
     pr_info("device_release(%p,%p)\n", inode, file);
 
-    module_put(THIS_MODULE);
     return 0;
 }
 

examples/procfs3.c

@@ -52,12 +52,10 @@ static ssize_t procfs_write(struct file *file, const char __user *buffer,
 }
 static int procfs_open(struct inode *inode, struct file *file)
 {
-    try_module_get(THIS_MODULE);
     return 0;
 }
 static int procfs_close(struct inode *inode, struct file *file)
 {
-    module_put(THIS_MODULE);
     return 0;
 }
 

examples/sleep.c

@@ -95,7 +95,6 @@ static int module_open(struct inode *inode, struct file *file)
     /* Try to get without blocking  */
     if (!atomic_cmpxchg(&already_open, 0, 1)) {
         /* Success without blocking, allow the access */
-        try_module_get(THIS_MODULE);
         return 0;
     }
     /* If the file's flags include O_NONBLOCK, it means the process does not
@@ -106,12 +105,6 @@ static int module_open(struct inode *inode, struct file *file)
     if (file->f_flags & O_NONBLOCK)
         return -EAGAIN;
 
-    /* This is the correct place for try_module_get(THIS_MODULE) because if
-     * a process is in the loop, which is within the kernel module,
-     * the kernel module must not be removed.
-     */
-    try_module_get(THIS_MODULE);
-
     while (atomic_cmpxchg(&already_open, 0, 1)) {
         int i, is_sig = 0;
 
@@ -132,15 +125,7 @@ static int module_open(struct inode *inode, struct file *file)
             is_sig = current->pending.signal.sig[i] & ~current->blocked.sig[i];
 
         if (is_sig) {
-            /* It is important to put module_put(THIS_MODULE) here, because
-             * for processes where the open is interrupted there will never
-             * be a corresponding close. If we do not decrement the usage
-             * count here, we will be left with a positive usage count
-             * which we will have no way to bring down to zero, giving us
-             * an immortal module, which can only be killed by rebooting
-             * the machine.
-             */
-            module_put(THIS_MODULE);
+            /* Return -EINTR if we got a signal */
             return -EINTR;
         }
     }
@@ -163,8 +148,6 @@ static int module_close(struct inode *inode, struct file *file)
      */
     wake_up(&waitq);
 
-    module_put(THIS_MODULE);
-
     return 0; /* success */
 }
 

examples/static_key.c

@@ -100,8 +100,6 @@ static int device_open(struct inode *inode, struct file *file)
         pr_alert("do unlikely thing\n");
     pr_info("fastpath 2\n");
 
-    try_module_get(THIS_MODULE);
-
     return 0;
 }
 
@@ -113,12 +111,6 @@ static int device_release(struct inode *inode, struct file *file)
     /* We are now ready for our next caller. */
     atomic_set(&already_open, CDEV_NOT_USED);
 
-    /**
-     * Decrement the usage count, or else once you opened the file, you will
-     * never get rid of the module.
-     */
-    module_put(THIS_MODULE);
-
     return 0;
 }
 

examples/vinput.c

@@ -157,8 +157,6 @@ static void vinput_destroy_vdevice(struct vinput *vinput)
     clear_bit(vinput->id, vinput_ids);
     spin_unlock(&vinput_lock);
 
-    module_put(THIS_MODULE);
-
     kfree(vinput);
 }
 
@@ -182,8 +180,6 @@ static struct vinput *vinput_alloc_vdevice(void)
         return ERR_PTR(-ENOMEM);
     }
 
-    try_module_get(THIS_MODULE);
-
     spin_lock_init(&vinput->lock);
 
     spin_lock(&vinput_lock);
@@ -217,7 +213,6 @@ static struct vinput *vinput_alloc_vdevice(void)
     list_del(&vinput->list);
 fail_id:
     spin_unlock(&vinput_lock);
-    module_put(THIS_MODULE);
     kfree(vinput);
 
     return ERR_PTR(err);

lkmpg.tex

@@ -1092,16 +1092,14 @@ \subsection{Unregistering A Device}
 You can see what its value is by looking at the 3rd field with the command \sh|cat /proc/modules| or \sh|lsmod|.
 If this number isn't zero, \sh|rmmod| will fail.
 Note that you do not have to check the counter within \cpp|cleanup_module| because the check will be performed for you by the system call \cpp|sys_delete_module|, defined in \src{include/linux/syscalls.h}.
-You should not use this counter directly, but there are functions defined in \src{include/linux/module.h} which let you increase, decrease and display this counter:
+You should not use this counter directly, but there are functions defined in \src{include/linux/module.h} which let you display this counter:
 
 \begin{itemize}
-  \item \cpp|try_module_get(THIS_MODULE)|: Increment the reference count of current module.
-  \item \cpp|module_put(THIS_MODULE)|: Decrement the reference count of current module.
   \item \cpp|module_refcount(THIS_MODULE)|: Return the value of reference count of current module.
 \end{itemize}
 
-It is important to keep the counter accurate; if you ever lose track of the correct usage count, you will never be able to unload the module; it is now reboot time.
-This is bound to happen to you sooner or later during a module's development.
+Note: The use of \cpp|try_module_get(THIS_MODULE)| and \cpp|module_put(THIS_MODULE)| within a module's own code is considered unsafe and should be avoided.
+The kernel automatically manages the reference count when file operations are in progress, so manual reference counting is unnecessary and can lead to race conditions.
 
 \subsection{chardev.c}
 \label{sec:chardev_c}