sbi->catatonic = 1;
        wq = sbi->queues;
        sbi->queues = NULL;     /* Erase all wait queues */
-       while ( wq ) {
+       while (wq) {
                nwq = wq->next;
                wq->status = -ENOENT; /* Magic is gone - report failure */
                kfree(wq->name);
                fput(sbi->pipe);        /* Close the pipe */
                sbi->pipe = NULL;
        }
-
        shrink_dcache_sb(sbi->sb);
 }
 
        int len, status;
 
        /* In catatonic mode, we don't wait for nobody */
-       if ( sbi->catatonic )
+       if (sbi->catatonic)
                return -ENOENT;
        
        name = kmalloc(NAME_MAX + 1, GFP_KERNEL);
                        break;
        }
 
-       if ( !wq ) {
+       if (!wq) {
                /* Can't wait for an expire if there's no mount */
                if (notify == NFY_NONE && !d_mountpoint(dentry)) {
                        kfree(name);
 
                /* Create a new wait queue */
                wq = kmalloc(sizeof(struct autofs_wait_queue),GFP_KERNEL);
-               if ( !wq ) {
+               if (!wq) {
                        kfree(name);
                        mutex_unlock(&sbi->wq_mutex);
                        return -ENOMEM;
 
        /* wq->name is NULL if and only if the lock is already released */
 
-       if ( sbi->catatonic ) {
+       if (sbi->catatonic) {
                /* We might have slept, so check again for catatonic mode */
                wq->status = -ENOENT;
                kfree(wq->name);
                wq->name = NULL;
        }
 
-       if ( wq->name ) {
+       if (wq->name) {
                /* Block all but "shutdown" signals while waiting */
                sigset_t oldset;
                unsigned long irqflags;
        struct autofs_wait_queue *wq, **wql;
 
        mutex_lock(&sbi->wq_mutex);
-       for ( wql = &sbi->queues ; (wq = *wql) != 0 ; wql = &wq->next ) {
-               if ( wq->wait_queue_token == wait_queue_token )
+       for (wql = &sbi->queues ; (wq = *wql) != 0 ; wql = &wq->next) {
+               if (wq->wait_queue_token == wait_queue_token)
                        break;
        }
 
-       if ( !wq ) {
+       if (!wq) {
                mutex_unlock(&sbi->wq_mutex);
                return -EINVAL;
        }