URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [autofs4/] [expire.c] - Rev 1765
Compare with Previous | Blame | View Log
/* -*- c -*- --------------------------------------------------------------- * * * linux/fs/autofs/expire.c * * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org> * * 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 "autofs_i.h" /* * Determine if a subtree of the namespace is busy. * * mnt is the mount tree under the autofs mountpoint */ static inline int is_vfsmnt_tree_busy(struct vfsmount *mnt) { struct vfsmount *this_parent = mnt; struct list_head *next; int count; count = atomic_read(&mnt->mnt_count) - 1; repeat: next = this_parent->mnt_mounts.next; DPRINTK(("is_vfsmnt_tree_busy: mnt=%p, this_parent=%p, next=%p\n", mnt, this_parent, next)); resume: for( ; next != &this_parent->mnt_mounts; next = next->next) { struct vfsmount *p = list_entry(next, struct vfsmount, mnt_child); /* -1 for struct vfs_mount's normal count, -1 to compensate for child's reference to parent */ count += atomic_read(&p->mnt_count) - 1 - 1; DPRINTK(("is_vfsmnt_tree_busy: p=%p, count now %d\n", p, count)); if (!list_empty(&p->mnt_mounts)) { this_parent = p; goto repeat; } /* root is busy if any leaf is busy */ if (atomic_read(&p->mnt_count) > 1) return 1; } /* All done at this level ... ascend and resume the search. */ if (this_parent != mnt) { next = this_parent->mnt_child.next; this_parent = this_parent->mnt_parent; goto resume; } DPRINTK(("is_vfsmnt_tree_busy: count=%d\n", count)); return count != 0; /* remaining users? */ } /* Traverse a dentry's list of vfsmounts and return the number of non-busy mounts */ static int check_vfsmnt(struct vfsmount *mnt, struct dentry *dentry) { int ret = dentry->d_mounted; struct vfsmount *vfs = lookup_mnt(mnt, dentry); if (vfs && is_vfsmnt_tree_busy(vfs)) ret--; DPRINTK(("check_vfsmnt: ret=%d\n", ret)); return ret; } /* Check dentry tree for busyness. If a dentry appears to be busy because it is a mountpoint, check to see if the mounted filesystem is busy. */ static int is_tree_busy(struct vfsmount *topmnt, struct dentry *top) { struct dentry *this_parent; struct list_head *next; int count; count = atomic_read(&top->d_count); DPRINTK(("is_tree_busy: top=%p initial count=%d\n", top, count)); this_parent = top; if (is_autofs4_dentry(top)) { count--; DPRINTK(("is_tree_busy: autofs; count=%d\n", count)); } if (d_mountpoint(top)) count -= check_vfsmnt(topmnt, top); repeat: next = this_parent->d_subdirs.next; resume: while (next != &this_parent->d_subdirs) { int adj = 0; struct dentry *dentry = list_entry(next, struct dentry, d_child); next = next->next; count += atomic_read(&dentry->d_count) - 1; if (d_mountpoint(dentry)) adj += check_vfsmnt(topmnt, dentry); if (is_autofs4_dentry(dentry)) { adj++; DPRINTK(("is_tree_busy: autofs; adj=%d\n", adj)); } count -= adj; if (!list_empty(&dentry->d_subdirs)) { this_parent = dentry; goto repeat; } if (atomic_read(&dentry->d_count) != adj) { DPRINTK(("is_tree_busy: busy leaf (d_count=%d adj=%d)\n", atomic_read(&dentry->d_count), adj)); return 1; } } /* All done at this level ... ascend and resume the search. */ if (this_parent != top) { next = this_parent->d_child.next; this_parent = this_parent->d_parent; goto resume; } DPRINTK(("is_tree_busy: count=%d\n", count)); return count != 0; /* remaining users? */ } /* * Find an eligible tree to time-out * A tree is eligible if :- * - it is unused by any user process * - it has been unused for exp_timeout time */ static struct dentry *autofs4_expire(struct super_block *sb, struct vfsmount *mnt, struct autofs_sb_info *sbi, int do_now) { unsigned long now = jiffies; unsigned long timeout; struct dentry *root = sb->s_root; struct list_head *tmp; if (!sbi->exp_timeout || !root) return NULL; timeout = sbi->exp_timeout; spin_lock(&dcache_lock); for(tmp = root->d_subdirs.next; tmp != &root->d_subdirs; tmp = tmp->next) { struct autofs_info *ino; struct dentry *dentry = list_entry(tmp, struct dentry, d_child); if (dentry->d_inode == NULL) continue; ino = autofs4_dentry_ino(dentry); if (ino == NULL) { /* dentry in the process of being deleted */ continue; } /* No point expiring a pending mount */ if (dentry->d_flags & DCACHE_AUTOFS_PENDING) continue; if (!do_now) { /* Too young to die */ if (time_after(ino->last_used + timeout, now)) continue; /* update last_used here :- - obviously makes sense if it is in use now - less obviously, prevents rapid-fire expire attempts if expire fails the first time */ ino->last_used = now; } if (!is_tree_busy(mnt, dentry)) { DPRINTK(("autofs_expire: returning %p %.*s\n", dentry, (int)dentry->d_name.len, dentry->d_name.name)); /* Start from here next time */ list_del(&root->d_subdirs); list_add(&root->d_subdirs, &dentry->d_child); dget(dentry); spin_unlock(&dcache_lock); return dentry; } } spin_unlock(&dcache_lock); return NULL; } /* Perform an expiry operation */ int autofs4_expire_run(struct super_block *sb, struct vfsmount *mnt, struct autofs_sb_info *sbi, struct autofs_packet_expire *pkt_p) { struct autofs_packet_expire pkt; struct dentry *dentry; memset(&pkt,0,sizeof pkt); pkt.hdr.proto_version = sbi->version; pkt.hdr.type = autofs_ptype_expire; if ((dentry = autofs4_expire(sb, mnt, sbi, 0)) == NULL) return -EAGAIN; pkt.len = dentry->d_name.len; memcpy(pkt.name, dentry->d_name.name, pkt.len); pkt.name[pkt.len] = '\0'; dput(dentry); if ( copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)) ) return -EFAULT; return 0; } /* Call repeatedly until it returns -EAGAIN, meaning there's nothing more to be done */ int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt, struct autofs_sb_info *sbi, int *arg) { struct dentry *dentry; int ret = -EAGAIN; int do_now = 0; if (arg && get_user(do_now, arg)) return -EFAULT; if ((dentry = autofs4_expire(sb, mnt, sbi, do_now)) != NULL) { struct autofs_info *de_info = autofs4_dentry_ino(dentry); /* This is synchronous because it makes the daemon a little easier */ de_info->flags |= AUTOFS_INF_EXPIRING; ret = autofs4_wait(sbi, &dentry->d_name, NFY_EXPIRE); de_info->flags &= ~AUTOFS_INF_EXPIRING; dput(dentry); } return ret; }