> * would work in any case. */
>#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
> for(i=0; i<_NSIG_WORDS && !is_sig; i++) is_sig = current->signal.sig[i] & current->blocked.sig[i];
> if (is_sig) {
>#else
> if (current->signal & current->blocked) {
>#endif
> /* It's important to put MOD_DEC_USE_COUNT here,
> * because for processes where the open is
> * interrupted there will never be a corresponding
> * close. If we don't decrement the usage count
> * here, we will be left with a positive usage
> * count which we'll have no way to bring down to
> * zero, giving us an immortal module, which can
> * only be killed by rebooting the machine. */
> MOD_DEC_USE_COUNT;
> return -EINTR;
> }
> }
> /* If we got here, Already_Open must be zero */
> /* Open the file */
> Already_Open = 1;
> return 0; /* Allow the access */
>}
>/* Called when the /proc file is closed */
>#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
>int module_close(struct inode *inode, struct file *file)
>#else
>void module_close(struct inode *inode, struct file *file)
>#endif
>{
> /* Set Already_Open to zero, so one of the processes
> * in the WaitQ will be able to set Already_Open back
> * to one and to open the file. All the other processes
> * will be called when Already_Open is back to one, so
> * they'll go back to sleep. */
> Already_Open = 0;
> /* Wake up all the processes in WaitQ, so if anybody
> * is waiting for the file, they can have it. */
> module_wake_up(&WaitQ);
> MOD_DEC_USE_COUNT;
>#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
> return 0; /* success */
>#endif
>}
>/* This function decides whether to allow an operation
>* (return zero) or not allow it (return a non-zero
>* which indicates why it is not allowed).
>*
>* The operation can be one of the following values:
>* 0 - Execute (run the "file" - meaningless in our case)
>* 2 - Write (input to the kernel module)
>* 4 - Read (output from the kernel module)
>*
>* This is the real function that checks file
>* permissions. The permissions returned by ls -l are
>* for referece only, and can be overridden here. */
>static int module_permission(struct inode *inode, int op) {
> /* We allow everybody to read from our module, but
> * only root (uid 0) may write to it */
> if (op == 4 || (op == 2 && current->euid == 0)) return 0;
> /* If it's anything else, access is denied */
> return -EACCES;
>}
>/* Structures to register as the /proc file, with
>* pointers to all the relevant functions. *********** */
>/* File operations for our proc file. This is where
