patch-2.0.31 linux/fs/autofs/root.c

• Lines: 446
• Date: Fri Sep 5 20:43:59 1997
• Orig file: v2.0.30/linux/fs/autofs/root.c
• Orig date: Wed Dec 31 16:00:00 1969

diff -u --recursive --new-file v2.0.30/linux/fs/autofs/root.c linux/fs/autofs/root.c
@@ -0,0 +1,445 @@
+/* -*- linux-c -*- --------------------------------------------------------- *
+ *
+ * linux/fs/autofs/root.c
+ *
+ *  Copyright 1997 Transmeta Corporation -- All Rights Reserved
+ *
+ * This file is part of the Linux kernel and is made available under
+ * the terms of the GNU General Public License, version 2, or at your
+ * option, any later version, incorporated herein by reference.
+ *
+ * ------------------------------------------------------------------------- */
+
+#include <linux/errno.h>
+#include <linux/stat.h>
+#include <linux/param.h>
+#include "autofs_i.h"
+
+static int autofs_root_readdir(struct inode *,struct file *,void *,filldir_t);
+static int autofs_root_lookup(struct inode *,const char *,int,struct inode **);
+static int autofs_root_symlink(struct inode *,const char *,int,const char *);
+static int autofs_root_unlink(struct inode *,const char *,int);
+static int autofs_root_rmdir(struct inode *,const char *,int);
+static int autofs_root_mkdir(struct inode *,const char *,int,int);
+static int autofs_root_ioctl(struct inode *, struct file *,unsigned int,unsigned long);
+
+static struct file_operations autofs_root_operations = {
+        NULL,                   /* lseek */
+        NULL,                   /* read */
+        NULL,                   /* write */
+        autofs_root_readdir,    /* readdir */
+        NULL,                   /* select */
+        autofs_root_ioctl,	/* ioctl */
+        NULL,                   /* mmap */
+        NULL,                   /* open */
+        NULL,                   /* release */
+        NULL                    /* fsync */
+};
+
+struct inode_operations autofs_root_inode_operations = {
+        &autofs_root_operations, /* file operations */
+        NULL,                   /* create */
+        autofs_root_lookup,     /* lookup */
+        NULL,                   /* link */
+        autofs_root_unlink,     /* unlink */
+        autofs_root_symlink,    /* symlink */
+        autofs_root_mkdir,      /* mkdir */
+        autofs_root_rmdir,      /* rmdir */
+        NULL,                   /* mknod */
+        NULL,                   /* rename */
+        NULL,                   /* readlink */
+        NULL,                   /* follow_link */
+        NULL,                   /* readpage */
+        NULL,                   /* writepage */
+        NULL,                   /* bmap */
+        NULL,                   /* truncate */
+        NULL                    /* permission */
+};
+
+static int autofs_root_readdir(struct inode *inode, struct file *filp,
+			       void *dirent, filldir_t filldir)
+{
+	struct autofs_dir_ent *ent;
+	struct autofs_dirhash *dirhash;
+	off_t onr, nr;
+
+	if (!inode || !S_ISDIR(inode->i_mode))
+		return -ENOTDIR;
+
+	dirhash = &((struct autofs_sb_info *)inode->i_sb->u.generic_sbp)->dirhash;
+	nr = filp->f_pos;
+
+	switch(nr)
+	{
+	case 0:
+		if (filldir(dirent, ".", 1, nr, inode->i_ino) < 0)
+			return 0;
+		filp->f_pos = ++nr;
+		/* fall through */
+	case 1:
+		if (filldir(dirent, "..", 2, nr, inode->i_ino) < 0)
+			return 0;
+		filp->f_pos = ++nr;
+		/* fall through */
+	default:
+		while ( onr = nr, ent = autofs_hash_enum(dirhash,&nr) ) {
+			if (filldir(dirent,ent->name,ent->len,onr,ent->ino) < 0)
+				return 0;
+			filp->f_pos = nr;
+		}
+		break;
+	}
+
+	return 0;
+}
+
+static int autofs_root_lookup(struct inode *dir, const char *name, int len,
+			      struct inode **result)
+{
+	struct autofs_sb_info *sbi;
+	struct autofs_dir_ent *ent;
+	struct inode *res;
+	autofs_hash_t hash;
+	int status, oz_mode;
+
+	DPRINTK(("autofs_root_lookup: name = "));
+	autofs_say(name,len);
+
+	*result = NULL;
+	if (!dir)
+		return -ENOENT;
+	if (!S_ISDIR(dir->i_mode)) {
+		iput(dir);
+		return -ENOTDIR;
+	}
+
+	/* Handle special cases: . and ..; since this is a root directory,
+	   they both point to the inode itself */
+	*result = dir;
+	if (!len)
+		return 0;
+	if (name[0] == '.') {
+		if (len == 1)
+			return 0;
+		if (name[1] == '.' && len == 2)
+			return 0;
+	}
+
+	*result = res = NULL;
+	sbi = (struct autofs_sb_info *) dir->i_sb->u.generic_sbp;
+
+	hash = autofs_hash(name,len);
+
+	oz_mode = autofs_oz_mode(sbi);
+	DPRINTK(("autofs_lookup: pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d\n", current->pid, current->pgrp, sbi->catatonic, oz_mode));
+
+	do {
+		while ( !(ent = autofs_hash_lookup(&sbi->dirhash,hash,name,len)) ) {
+			DPRINTK(("lookup failed, pid = %u, pgrp = %u\n", current->pid, current->pgrp));
+			
+			if ( oz_mode ) {
+				iput(dir);
+				return -ENOENT;
+			} else {
+				status = autofs_wait(sbi,hash,name,len);
+				DPRINTK(("autofs_wait returned %d\n", status));
+				if ( status ) {
+					iput(dir);
+					return status;
+				}
+			}
+		}
+
+		DPRINTK(("lookup successful, inode = %08x\n", (unsigned int)ent->ino));
+
+		if (!(res = iget(dir->i_sb,ent->ino))) {
+			printk("autofs: iget returned null!\n");
+			iput(dir);
+			return -EACCES;
+		}
+		
+		if ( !oz_mode && S_ISDIR(res->i_mode) && res->i_sb == dir->i_sb ) {
+			/* Not a mount point yet, call 1-800-DAEMON */
+			DPRINTK(("autofs: waiting on non-mountpoint dir, inode = %lu, pid = %u, pgrp = %u\n", res->i_ino, current->pid, current->pgrp));
+			iput(res);
+			res = NULL;
+			status = autofs_wait(sbi,hash,name,len);
+			if ( status ) {
+				iput(dir);
+				return status;
+			}
+		}
+	} while(!res);
+	autofs_update_usage(&sbi->dirhash,ent);
+	
+	*result = res;
+	iput(dir);
+	return 0;
+}
+
+static int autofs_root_symlink(struct inode *dir, const char *name, int len, const char *symname)
+{
+	struct autofs_sb_info *sbi = (struct autofs_sb_info *) dir->i_sb->u.generic_sbp;
+	struct autofs_dirhash *dh = &sbi->dirhash;
+	autofs_hash_t hash = autofs_hash(name,len);
+	struct autofs_dir_ent *ent;
+	unsigned int n;
+	int slsize;
+	struct autofs_symlink *sl;
+
+	DPRINTK(("autofs_root_symlink: %s <- ", symname));
+	autofs_say(name,len);
+
+	if ( !autofs_oz_mode(sbi) ) {
+		iput(dir);
+		return -EPERM;
+	}
+	if ( autofs_hash_lookup(dh,hash,name,len) ) {
+		iput(dir);
+		return -EEXIST;
+	}
+	n = find_first_zero_bit(sbi->symlink_bitmap,AUTOFS_MAX_SYMLINKS);
+	if ( n >= AUTOFS_MAX_SYMLINKS ) {
+		iput(dir);
+		return -ENOSPC;
+	}
+	set_bit(n,sbi->symlink_bitmap);
+	sl = &sbi->symlink[n];
+	sl->len = strlen(symname);
+	sl->data = kmalloc(slsize = sl->len+1, GFP_KERNEL);
+	if ( !sl->data ) {
+		clear_bit(n,sbi->symlink_bitmap);
+		iput(dir);
+		return -ENOSPC;
+	}
+	ent = kmalloc(sizeof(struct autofs_dir_ent), GFP_KERNEL);
+	if ( !ent ) {
+		kfree(sl->data);
+		clear_bit(n,sbi->symlink_bitmap);
+		iput(dir);
+		return -ENOSPC;
+	}
+	ent->name = kmalloc(len, GFP_KERNEL);
+	if ( !ent->name ) {
+		kfree(sl->data);
+		kfree(ent);
+		clear_bit(n,sbi->symlink_bitmap);
+		iput(dir);
+		return -ENOSPC;
+	}
+	memcpy(sl->data,symname,slsize);
+	sl->mtime = CURRENT_TIME;
+
+	ent->ino = AUTOFS_FIRST_SYMLINK + n;
+	ent->hash = hash;
+	memcpy(ent->name,name,ent->len = len);
+
+	autofs_hash_insert(dh,ent);
+	iput(dir);
+
+	return 0;
+}
+
+static int autofs_root_unlink(struct inode *dir, const char *name, int len)
+{
+	struct autofs_sb_info *sbi = (struct autofs_sb_info *) dir->i_sb->u.generic_sbp;
+	struct autofs_dirhash *dh = &sbi->dirhash;
+	autofs_hash_t hash = autofs_hash(name,len);
+	struct autofs_dir_ent *ent;
+	unsigned int n;
+
+	iput(dir);		/* Nothing below can sleep */
+
+	if ( !autofs_oz_mode(sbi) )
+		return -EPERM;
+
+	ent = autofs_hash_lookup(dh,hash,name,len);
+	if ( !ent )
+		return -ENOENT;
+
+	n = ent->ino - AUTOFS_FIRST_SYMLINK;
+	if ( n >= AUTOFS_MAX_SYMLINKS || !test_bit(n,sbi->symlink_bitmap) )
+		return -EINVAL;	/* Not a symlink inode, can't unlink */
+
+	autofs_hash_delete(ent);
+	clear_bit(n,sbi->symlink_bitmap);
+	kfree(sbi->symlink[n].data);
+	
+	return 0;
+}
+
+static int autofs_root_rmdir(struct inode *dir, const char *name, int len)
+{
+	struct autofs_sb_info *sbi = (struct autofs_sb_info *) dir->i_sb->u.generic_sbp;
+	struct autofs_dirhash *dh = &sbi->dirhash;
+	autofs_hash_t hash = autofs_hash(name,len);
+	struct autofs_dir_ent *ent;
+
+	if ( !autofs_oz_mode(sbi) ) {
+		iput(dir);
+		return -EPERM;
+	}
+	ent = autofs_hash_lookup(dh,hash,name,len);
+	if ( !ent ) {
+		iput(dir);
+		return -ENOENT;
+	}
+	if ( (unsigned int)ent->ino < AUTOFS_FIRST_DIR_INO ) {
+		iput(dir);
+		return -ENOTDIR; /* Not a directory */
+	}
+	autofs_hash_delete(ent);
+	dir->i_nlink--;
+	iput(dir);
+
+	return 0;
+}
+
+static int autofs_root_mkdir(struct inode *dir, const char *name, int len, int mode)
+{
+	struct autofs_sb_info *sbi = (struct autofs_sb_info *) dir->i_sb->u.generic_sbp;
+	struct autofs_dirhash *dh = &sbi->dirhash;
+	autofs_hash_t hash = autofs_hash(name,len);
+	struct autofs_dir_ent *ent;
+
+	if ( !autofs_oz_mode(sbi) ) {
+		iput(dir);
+		return -EPERM;
+	}
+	ent = autofs_hash_lookup(dh,hash,name,len);
+	if ( ent ) {
+		iput(dir);
+		return -EEXIST;
+	}
+	if ( sbi->next_dir_ino < AUTOFS_FIRST_DIR_INO ) {
+		printk("autofs: Out of inode numbers -- what the heck did you do??\n");
+		iput(dir);
+		return -ENOSPC;
+	}
+	ent = kmalloc(sizeof(struct autofs_dir_ent), GFP_KERNEL);
+	if ( !ent ) {
+		iput(dir);
+		return -ENOSPC;
+	}
+	ent->name = kmalloc(len, GFP_KERNEL);
+	if ( !ent->name ) {
+		kfree(ent);
+		iput(dir);
+		return -ENOSPC;
+	}
+	ent->hash = hash;
+	memcpy(ent->name, name, ent->len = len);
+	ent->ino = sbi->next_dir_ino++;
+	autofs_hash_insert(dh,ent);
+	dir->i_nlink++;
+	iput(dir);
+
+	return 0;
+}
+
+/* Get/set timeout ioctl() operation */
+static inline int autofs_get_set_timeout(struct autofs_sb_info *sbi,
+					 unsigned long *p)
+{
+	int rv;
+	unsigned long ntimeout;
+
+#if LINUX_VERSION_CODE < kver(2,1,0)
+	if ( (rv = verify_area(VERIFY_WRITE, p, sizeof(unsigned long))) )
+		return rv;
+	ntimeout = get_user(p);
+	put_user(sbi->exp_timeout/HZ, p);
+#else
+	if ( (rv = get_user(ntimeout, p)) ||
+	     (rv = put_user(sbi->exp_timeout/HZ, p)) )
+		return rv;
+#endif
+
+	if ( ntimeout > ULONG_MAX/HZ )
+		sbi->exp_timeout = 0;
+	else
+		sbi->exp_timeout = ntimeout * HZ;
+
+	return 0;
+}
+
+/* Return protocol version */
+static inline int autofs_get_protover(int *p)
+{
+#if LINUX_VERSION_CODE < kver(2,1,0)
+	int rv;
+	if ( (rv = verify_area(VERIFY_WRITE, p, sizeof(int))) )
+		return rv;
+	put_user(AUTOFS_PROTO_VERSION, p);
+	return 0;
+#else
+	return put_user(AUTOFS_PROTO_VERSION, p);
+#endif
+}
+
+/* Perform an expiry operation */
+static inline int autofs_expire_run(struct autofs_sb_info *sbi,
+				    struct autofs_packet_expire *pkt_p)
+{
+	struct autofs_dir_ent *ent;
+	struct autofs_packet_expire pkt;
+	struct autofs_dirhash *dh = &(sbi->dirhash);
+	
+	memset(&pkt,0,sizeof pkt);
+
+	pkt.hdr.proto_version = AUTOFS_PROTO_VERSION;
+	pkt.hdr.type = autofs_ptype_expire;
+
+	if ( !sbi->exp_timeout ||
+	     !(ent = autofs_expire(dh,sbi->exp_timeout)) )
+		return -EAGAIN;
+
+	pkt.len = ent->len;
+	memcpy(pkt.name, ent->name, pkt.len);
+	pkt.name[pkt.len] = '\0';
+
+	if ( copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)) )
+		return -EFAULT;
+	
+	autofs_update_usage(dh,ent);
+
+	return 0;
+}
+
+/*
+ * ioctl()'s on the root directory is the chief method for the daemon to
+ * generate kernel reactions
+ */
+static int autofs_root_ioctl(struct inode *inode, struct file *filp,
+			     unsigned int cmd, unsigned long arg)
+{
+	struct autofs_sb_info *sbi =
+		(struct autofs_sb_info *)inode->i_sb->u.generic_sbp;
+
+	DPRINTK(("autofs_ioctl: cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u\n",cmd,arg,sbi,current->pgrp));
+
+	if ( _IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) ||
+	     _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT )
+		return -ENOTTY;
+	
+	if ( !autofs_oz_mode(sbi) && !fsuser() )
+		return -EPERM;
+	
+	switch(cmd) {
+	case AUTOFS_IOC_READY:	/* Wait queue: go ahead and retry */
+		return autofs_wait_release(sbi,arg,0);
+	case AUTOFS_IOC_FAIL:	/* Wait queue: fail with ENOENT */
+		return autofs_wait_release(sbi,arg,-ENOENT);
+	case AUTOFS_IOC_CATATONIC: /* Enter catatonic mode (daemon shutdown) */
+		autofs_catatonic_mode(sbi);
+		return 0;
+	case AUTOFS_IOC_PROTOVER: /* Get protocol version */
+		return autofs_get_protover((int *)arg);
+	case AUTOFS_IOC_SETTIMEOUT:
+		return autofs_get_set_timeout(sbi,(unsigned long *)arg);
+	case AUTOFS_IOC_EXPIRE:
+		return autofs_expire_run(sbi,(struct autofs_packet_expire *)arg);
+	default:
+		return -ENOSYS;
+	}
+}