microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

fsnotify: rename mark_entry to just mark 

previously I used mark_entry when talking about marks on inodes.  The
_entry is pretty useless.  Just use "mark" instead.

Signed-off-by: Eric Paris <eparis@redhat.com>
This commit is contained in:
Eric Paris 2009-12-17 21:24:24 -05:00
Родитель d07754412f
Коммит 841bdc10f5
3 изменённых файлов: 90 добавлений и 90 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

6
fs/notify/group.c
Просмотреть файл

@ -74,11 +74,11 @@ void fsnotify_recalc_group_mask(struct fsnotify_group *group)
{ {
__u32 mask = 0; __u32 mask = 0;
__u32 old_mask = group->mask; __u32 old_mask = group->mask;
struct fsnotify_mark *entry; struct fsnotify_mark *mark;
spin_lock(&group->mark_lock); spin_lock(&group->mark_lock);
list_for_each_entry(entry, &group->marks_list, g_list) list_for_each_entry(mark, &group->marks_list, g_list)
mask |= entry->mask; mask |= mark->mask;
spin_unlock(&group->mark_lock); spin_unlock(&group->mark_lock);
group->mask = mask; group->mask = mask;

148
fs/notify/inode_mark.c
Просмотреть файл

@ -30,21 +30,21 @@
* There are 3 spinlocks involved with fsnotify inode marks and they MUST * There are 3 spinlocks involved with fsnotify inode marks and they MUST
* be taken in order as follows: * be taken in order as follows:
* *
* entry->lock * mark->lock
* group->mark_lock * group->mark_lock
* inode->i_lock * inode->i_lock
* *
* entry->lock protects 2 things, entry->group and entry->inode. You must hold * mark->lock protects 2 things, mark->group and mark->inode. You must hold
* that lock to dereference either of these things (they could be NULL even with * that lock to dereference either of these things (they could be NULL even with
* the lock) * the lock)
* *
* group->mark_lock protects the marks_list anchored inside a given group * group->mark_lock protects the marks_list anchored inside a given group
* and each entry is hooked via the g_list. It also sorta protects the * and each mark is hooked via the g_list. It also sorta protects the
* free_g_list, which when used is anchored by a private list on the stack of the * free_g_list, which when used is anchored by a private list on the stack of the
* task which held the group->mark_lock. * task which held the group->mark_lock.
* *
* inode->i_lock protects the i_fsnotify_marks list anchored inside a * inode->i_lock protects the i_fsnotify_marks list anchored inside a
* given inode and each entry is hooked via the i_list. (and sorta the * given inode and each mark is hooked via the i_list. (and sorta the
* free_i_list) * free_i_list)
* *
* *
@ -95,15 +95,15 @@
#include <linux/fsnotify_backend.h> #include <linux/fsnotify_backend.h>
#include "fsnotify.h" #include "fsnotify.h"
void fsnotify_get_mark(struct fsnotify_mark *entry) void fsnotify_get_mark(struct fsnotify_mark *mark)
{ {
atomic_inc(&entry->refcnt); atomic_inc(&mark->refcnt);
} }
void fsnotify_put_mark(struct fsnotify_mark *entry) void fsnotify_put_mark(struct fsnotify_mark *mark)
{ {
if (atomic_dec_and_test(&entry->refcnt)) if (atomic_dec_and_test(&mark->refcnt))
entry->free_mark(entry); mark->free_mark(mark);
} }
/* /*
@ -111,14 +111,14 @@ void fsnotify_put_mark(struct fsnotify_mark *entry)
*/ */
static void fsnotify_recalc_inode_mask_locked(struct inode *inode) static void fsnotify_recalc_inode_mask_locked(struct inode *inode)
{ {
struct fsnotify_mark *entry; struct fsnotify_mark *mark;
struct hlist_node *pos; struct hlist_node *pos;
__u32 new_mask = 0; __u32 new_mask = 0;
assert_spin_locked(&inode->i_lock); assert_spin_locked(&inode->i_lock);
hlist_for_each_entry(entry, pos, &inode->i_fsnotify_marks, i.i_list) hlist_for_each_entry(mark, pos, &inode->i_fsnotify_marks, i.i_list)
new_mask |= entry->mask; new_mask |= mark->mask;
inode->i_fsnotify_mask = new_mask; inode->i_fsnotify_mask = new_mask;
} }
@ -138,40 +138,40 @@ void fsnotify_recalc_inode_mask(struct inode *inode)
/* /*
* Any time a mark is getting freed we end up here. * Any time a mark is getting freed we end up here.
* The caller had better be holding a reference to this mark so we don't actually * The caller had better be holding a reference to this mark so we don't actually
* do the final put under the entry->lock * do the final put under the mark->lock
*/ */
void fsnotify_destroy_mark(struct fsnotify_mark *entry) void fsnotify_destroy_mark(struct fsnotify_mark *mark)
{ {
struct fsnotify_group *group; struct fsnotify_group *group;
struct inode *inode; struct inode *inode;
spin_lock(&entry->lock); spin_lock(&mark->lock);
group = entry->group; group = mark->group;
inode = entry->i.inode; inode = mark->i.inode;
BUG_ON(group && !inode); BUG_ON(group && !inode);
BUG_ON(!group && inode); BUG_ON(!group && inode);
/* if !group something else already marked this to die */ /* if !group something else already marked this to die */
if (!group) { if (!group) {
spin_unlock(&entry->lock); spin_unlock(&mark->lock);
return; return;
} }
/* 1 from caller and 1 for being on i_list/g_list */ /* 1 from caller and 1 for being on i_list/g_list */
BUG_ON(atomic_read(&entry->refcnt) < 2); BUG_ON(atomic_read(&mark->refcnt) < 2);
spin_lock(&group->mark_lock); spin_lock(&group->mark_lock);
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
hlist_del_init(&entry->i.i_list); hlist_del_init(&mark->i.i_list);
entry->i.inode = NULL; mark->i.inode = NULL;
list_del_init(&entry->g_list); list_del_init(&mark->g_list);
entry->group = NULL; mark->group = NULL;
fsnotify_put_mark(entry); /* for i_list and g_list */ fsnotify_put_mark(mark); /* for i_list and g_list */
/* /*
* this mark is now off the inode->i_fsnotify_marks list and we * this mark is now off the inode->i_fsnotify_marks list and we
@ -182,21 +182,21 @@ void fsnotify_destroy_mark(struct fsnotify_mark *entry)
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
spin_unlock(&group->mark_lock); spin_unlock(&group->mark_lock);
spin_unlock(&entry->lock); spin_unlock(&mark->lock);
/* /*
* Some groups like to know that marks are being freed. This is a * Some groups like to know that marks are being freed. This is a
* callback to the group function to let it know that this entry * callback to the group function to let it know that this mark
* is being freed. * is being freed.
*/ */
if (group->ops->freeing_mark) if (group->ops->freeing_mark)
group->ops->freeing_mark(entry, group); group->ops->freeing_mark(mark, group);
/* /*
* __fsnotify_update_child_dentry_flags(inode); * __fsnotify_update_child_dentry_flags(inode);
* *
* I really want to call that, but we can't, we have no idea if the inode * I really want to call that, but we can't, we have no idea if the inode
* still exists the second we drop the entry->lock. * still exists the second we drop the mark->lock.
* *
* The next time an event arrive to this inode from one of it's children * The next time an event arrive to this inode from one of it's children
* __fsnotify_parent will see that the inode doesn't care about it's * __fsnotify_parent will see that the inode doesn't care about it's
@ -221,20 +221,20 @@ void fsnotify_destroy_mark(struct fsnotify_mark *entry)
*/ */
void fsnotify_clear_marks_by_group(struct fsnotify_group *group) void fsnotify_clear_marks_by_group(struct fsnotify_group *group)
{ {
struct fsnotify_mark *lentry, *entry; struct fsnotify_mark *lmark, *mark;
LIST_HEAD(free_list); LIST_HEAD(free_list);
spin_lock(&group->mark_lock); spin_lock(&group->mark_lock);
list_for_each_entry_safe(entry, lentry, &group->marks_list, g_list) { list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) {
list_add(&entry->free_g_list, &free_list); list_add(&mark->free_g_list, &free_list);
list_del_init(&entry->g_list); list_del_init(&mark->g_list);
fsnotify_get_mark(entry); fsnotify_get_mark(mark);
} }
spin_unlock(&group->mark_lock); spin_unlock(&group->mark_lock);
list_for_each_entry_safe(entry, lentry, &free_list, free_g_list) { list_for_each_entry_safe(mark, lmark, &free_list, free_g_list) {
fsnotify_destroy_mark(entry); fsnotify_destroy_mark(mark);
fsnotify_put_mark(entry); fsnotify_put_mark(mark);
} }
} }
@ -243,21 +243,21 @@ void fsnotify_clear_marks_by_group(struct fsnotify_group *group)
*/ */
void fsnotify_clear_marks_by_inode(struct inode *inode) void fsnotify_clear_marks_by_inode(struct inode *inode)
{ {
struct fsnotify_mark *entry, *lentry; struct fsnotify_mark *mark, *lmark;
struct hlist_node *pos, *n; struct hlist_node *pos, *n;
LIST_HEAD(free_list); LIST_HEAD(free_list);
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
hlist_for_each_entry_safe(entry, pos, n, &inode->i_fsnotify_marks, i.i_list) { hlist_for_each_entry_safe(mark, pos, n, &inode->i_fsnotify_marks, i.i_list) {
list_add(&entry->i.free_i_list, &free_list); list_add(&mark->i.free_i_list, &free_list);
hlist_del_init(&entry->i.i_list); hlist_del_init(&mark->i.i_list);
fsnotify_get_mark(entry); fsnotify_get_mark(mark);
} }
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
list_for_each_entry_safe(entry, lentry, &free_list, i.free_i_list) { list_for_each_entry_safe(mark, lmark, &free_list, i.free_i_list) {
fsnotify_destroy_mark(entry); fsnotify_destroy_mark(mark);
fsnotify_put_mark(entry); fsnotify_put_mark(mark);
} }
} }
@ -268,15 +268,15 @@ void fsnotify_clear_marks_by_inode(struct inode *inode)
struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_group *group, struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_group *group,
struct inode *inode) struct inode *inode)
{ {
struct fsnotify_mark *entry; struct fsnotify_mark *mark;
struct hlist_node *pos; struct hlist_node *pos;
assert_spin_locked(&inode->i_lock); assert_spin_locked(&inode->i_lock);
hlist_for_each_entry(entry, pos, &inode->i_fsnotify_marks, i.i_list) { hlist_for_each_entry(mark, pos, &inode->i_fsnotify_marks, i.i_list) {
if (entry->group == group) { if (mark->group == group) {
fsnotify_get_mark(entry); fsnotify_get_mark(mark);
return entry; return mark;
} }
} }
return NULL; return NULL;
@ -294,35 +294,35 @@ void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *ol
/* /*
* Nothing fancy, just initialize lists and locks and counters. * Nothing fancy, just initialize lists and locks and counters.
*/ */
void fsnotify_init_mark(struct fsnotify_mark *entry, void fsnotify_init_mark(struct fsnotify_mark *mark,
void (*free_mark)(struct fsnotify_mark *entry)) void (*free_mark)(struct fsnotify_mark *mark))
{ {
spin_lock_init(&entry->lock); spin_lock_init(&mark->lock);
atomic_set(&entry->refcnt, 1); atomic_set(&mark->refcnt, 1);
INIT_HLIST_NODE(&entry->i.i_list); INIT_HLIST_NODE(&mark->i.i_list);
entry->group = NULL; mark->group = NULL;
entry->mask = 0; mark->mask = 0;
entry->i.inode = NULL; mark->i.inode = NULL;
entry->free_mark = free_mark; mark->free_mark = free_mark;
} }
/* /*
* Attach an initialized mark entry to a given group and inode. * Attach an initialized mark mark to a given group and inode.
* These marks may be used for the fsnotify backend to determine which * These marks may be used for the fsnotify backend to determine which
* event types should be delivered to which group and for which inodes. * event types should be delivered to which group and for which inodes.
*/ */
int fsnotify_add_mark(struct fsnotify_mark *entry, int fsnotify_add_mark(struct fsnotify_mark *mark,
struct fsnotify_group *group, struct inode *inode, struct fsnotify_group *group, struct inode *inode,
int allow_dups) int allow_dups)
{ {
struct fsnotify_mark *lentry = NULL; struct fsnotify_mark *lmark = NULL;
int ret = 0; int ret = 0;
inode = igrab(inode); inode = igrab(inode);
if (unlikely(!inode)) if (unlikely(!inode))
return -EINVAL; return -EINVAL;
entry->flags = FSNOTIFY_MARK_FLAG_INODE; mark->flags = FSNOTIFY_MARK_FLAG_INODE;
/* /*
* if this group isn't being testing for inode type events we need * if this group isn't being testing for inode type events we need
@ -340,24 +340,24 @@ int fsnotify_add_mark(struct fsnotify_mark *entry,
/* /*
* LOCKING ORDER!!!! * LOCKING ORDER!!!!
* entry->lock * mark->lock
* group->mark_lock * group->mark_lock
* inode->i_lock * inode->i_lock
*/ */
spin_lock(&entry->lock); spin_lock(&mark->lock);
spin_lock(&group->mark_lock); spin_lock(&group->mark_lock);
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
if (!allow_dups) if (!allow_dups)
lentry = fsnotify_find_mark(group, inode); lmark = fsnotify_find_mark(group, inode);
if (!lentry) { if (!lmark) {
entry->group = group; mark->group = group;
entry->i.inode = inode; mark->i.inode = inode;
hlist_add_head(&entry->i.i_list, &inode->i_fsnotify_marks); hlist_add_head(&mark->i.i_list, &inode->i_fsnotify_marks);
list_add(&entry->g_list, &group->marks_list); list_add(&mark->g_list, &group->marks_list);
fsnotify_get_mark(entry); /* for i_list and g_list */ fsnotify_get_mark(mark); /* for i_list and g_list */
atomic_inc(&group->num_marks); atomic_inc(&group->num_marks);
@ -366,12 +366,12 @@ int fsnotify_add_mark(struct fsnotify_mark *entry,
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
spin_unlock(&group->mark_lock); spin_unlock(&group->mark_lock);
spin_unlock(&entry->lock); spin_unlock(&mark->lock);
if (lentry) { if (lmark) {
ret = -EEXIST; ret = -EEXIST;
iput(inode); iput(inode);
fsnotify_put_mark(lentry); fsnotify_put_mark(lmark);
} else { } else {
__fsnotify_update_child_dentry_flags(inode); __fsnotify_update_child_dentry_flags(inode);
} }

26
include/linux/fsnotify_backend.h
Просмотреть файл

@ -83,7 +83,7 @@ struct fsnotify_ops {
int data_type); int data_type);
int (*handle_event)(struct fsnotify_group *group, struct fsnotify_event *event); int (*handle_event)(struct fsnotify_group *group, struct fsnotify_event *event);
void (*free_group_priv)(struct fsnotify_group *group); void (*free_group_priv)(struct fsnotify_group *group);
void (*freeing_mark)(struct fsnotify_mark *entry, struct fsnotify_group *group); void (*freeing_mark)(struct fsnotify_mark *mark, struct fsnotify_group *group);
void (*free_event_priv)(struct fsnotify_event_private_data *priv); void (*free_event_priv)(struct fsnotify_event_private_data *priv);
}; };
@ -135,7 +135,7 @@ struct fsnotify_group {
/* stores all fastpath marks assoc with this group so they can be cleaned on unregister */ /* stores all fastpath marks assoc with this group so they can be cleaned on unregister */
spinlock_t mark_lock; /* protect marks_list */ spinlock_t mark_lock; /* protect marks_list */
atomic_t num_marks; /* 1 for each mark entry and 1 for not being atomic_t num_marks; /* 1 for each mark and 1 for not being
* past the point of no return when freeing * past the point of no return when freeing
* a group */ * a group */
struct list_head marks_list; /* all inode marks for this group */ struct list_head marks_list; /* all inode marks for this group */
@ -229,7 +229,7 @@ struct fsnotify_event {
* Inode specific fields in an fsnotify_mark * Inode specific fields in an fsnotify_mark
*/ */
struct fsnotify_inode_mark { struct fsnotify_inode_mark {
struct inode *inode; /* inode this entry is associated with */ struct inode *inode; /* inode this mark is associated with */
struct hlist_node i_list; /* list of marks by inode->i_fsnotify_marks */ struct hlist_node i_list; /* list of marks by inode->i_fsnotify_marks */
struct list_head free_i_list; /* tmp list used when freeing this mark */ struct list_head free_i_list; /* tmp list used when freeing this mark */
}; };
@ -238,13 +238,13 @@ struct fsnotify_inode_mark {
* Mount point specific fields in an fsnotify_mark * Mount point specific fields in an fsnotify_mark
*/ */
struct fsnotify_vfsmount_mark { struct fsnotify_vfsmount_mark {
struct vfsmount *mnt; /* inode this entry is associated with */ struct vfsmount *mnt; /* vfsmount this mark is associated with */
struct hlist_node m_list; /* list of marks by inode->i_fsnotify_marks */ struct hlist_node m_list; /* list of marks by inode->i_fsnotify_marks */
struct list_head free_m_list; /* tmp list used when freeing this mark */ struct list_head free_m_list; /* tmp list used when freeing this mark */
}; };
/* /*
* a mark is simply an entry attached to an in core inode which allows an * a mark is simply an object attached to an in core inode which allows an
* fsnotify listener to indicate they are either no longer interested in events * fsnotify listener to indicate they are either no longer interested in events
* of a type matching mask or only interested in those events. * of a type matching mask or only interested in those events.
* *
@ -254,11 +254,11 @@ struct fsnotify_vfsmount_mark {
* inode eviction or modification. * inode eviction or modification.
*/ */
struct fsnotify_mark { struct fsnotify_mark {
__u32 mask; /* mask this mark entry is for */ __u32 mask; /* mask this mark is for */
/* we hold ref for each i_list and g_list. also one ref for each 'thing' /* we hold ref for each i_list and g_list. also one ref for each 'thing'
* in kernel that found and may be using this mark. */ * in kernel that found and may be using this mark. */
atomic_t refcnt; /* active things looking at this mark */ atomic_t refcnt; /* active things looking at this mark */
struct fsnotify_group *group; /* group this mark entry is for */ struct fsnotify_group *group; /* group this mark is for */
struct list_head g_list; /* list of marks by group->i_fsnotify_marks */ struct list_head g_list; /* list of marks by group->i_fsnotify_marks */
spinlock_t lock; /* protect group and inode */ spinlock_t lock; /* protect group and inode */
union { union {
@ -269,7 +269,7 @@ struct fsnotify_mark {
#define FSNOTIFY_MARK_FLAG_INODE 0x01 #define FSNOTIFY_MARK_FLAG_INODE 0x01
#define FSNOTIFY_MARK_FLAG_VFSMOUNT 0x02 #define FSNOTIFY_MARK_FLAG_VFSMOUNT 0x02
unsigned int flags; /* vfsmount or inode mark? */ unsigned int flags; /* vfsmount or inode mark? */
void (*free_mark)(struct fsnotify_mark *entry); /* called on final put+free */ void (*free_mark)(struct fsnotify_mark *mark); /* called on final put+free */
}; };
#ifdef CONFIG_FSNOTIFY #ifdef CONFIG_FSNOTIFY
@ -361,19 +361,19 @@ extern struct fsnotify_event *fsnotify_remove_notify_event(struct fsnotify_group
/* run all marks associated with an inode and update inode->i_fsnotify_mask */ /* run all marks associated with an inode and update inode->i_fsnotify_mask */
extern void fsnotify_recalc_inode_mask(struct inode *inode); extern void fsnotify_recalc_inode_mask(struct inode *inode);
extern void fsnotify_init_mark(struct fsnotify_mark *entry, void (*free_mark)(struct fsnotify_mark *entry)); extern void fsnotify_init_mark(struct fsnotify_mark *mark, void (*free_mark)(struct fsnotify_mark *mark));
/* find (and take a reference) to a mark associated with group and inode */ /* find (and take a reference) to a mark associated with group and inode */
extern struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_group *group, struct inode *inode); extern struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_group *group, struct inode *inode);
/* copy the values from old into new */ /* copy the values from old into new */
extern void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old); extern void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old);
/* attach the mark to both the group and the inode */ /* attach the mark to both the group and the inode */
extern int fsnotify_add_mark(struct fsnotify_mark *entry, struct fsnotify_group *group, struct inode *inode, int allow_dups); extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group, struct inode *inode, int allow_dups);
/* given a mark, flag it to be freed when all references are dropped */ /* given a mark, flag it to be freed when all references are dropped */
extern void fsnotify_destroy_mark(struct fsnotify_mark *entry); extern void fsnotify_destroy_mark(struct fsnotify_mark *mark);
/* run all the marks in a group, and flag them to be freed */ /* run all the marks in a group, and flag them to be freed */
extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group); extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group);
extern void fsnotify_get_mark(struct fsnotify_mark *entry); extern void fsnotify_get_mark(struct fsnotify_mark *mark);
extern void fsnotify_put_mark(struct fsnotify_mark *entry); extern void fsnotify_put_mark(struct fsnotify_mark *mark);
extern void fsnotify_unmount_inodes(struct list_head *list); extern void fsnotify_unmount_inodes(struct list_head *list);
/* put here because inotify does some weird stuff when destroying watches */ /* put here because inotify does some weird stuff when destroying watches */