fs/notify/fsnotify.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
   4  */
   5
   6 #include <linux/dcache.h>
   7 #include <linux/fs.h>
   8 #include <linux/gfp.h>
   9 #include <linux/init.h>
  10 #include <linux/module.h>
  11 #include <linux/mount.h>
  12 #include <linux/srcu.h>
  13
  14 #include <linux/fsnotify_backend.h>
  15 #include "fsnotify.h"
  16
  17 /*
  18  * Clear all of the marks on an inode when it is being evicted from core
  19  */
  20 void __fsnotify_inode_delete(struct inode *inode)
  21 {
  22         fsnotify_clear_marks_by_inode(inode);
  23 }
  24 EXPORT_SYMBOL_GPL(__fsnotify_inode_delete);
  25
  26 void __fsnotify_vfsmount_delete(struct vfsmount *mnt)
  27 {
  28         fsnotify_clear_marks_by_mount(mnt);
  29 }
  30
  31 /**
  32  * fsnotify_unmount_inodes - an sb is unmounting.  handle any watched inodes.
  33  * @sb: superblock being unmounted.
  34  *
  35  * Called during unmount with no locks held, so needs to be safe against
  36  * concurrent modifiers. We temporarily drop sb->s_inode_list_lock and CAN block.
  37  */
  38 static void fsnotify_unmount_inodes(struct super_block *sb)
  39 {
  40         struct inode *inode, *iput_inode = NULL;
  41
  42         spin_lock(&sb->s_inode_list_lock);
  43         list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
  44                 /*
  45                  * We cannot __iget() an inode in state I_FREEING,
  46                  * I_WILL_FREE, or I_NEW which is fine because by that point
  47                  * the inode cannot have any associated watches.
  48                  */
  49                 spin_lock(&inode->i_lock);
  50                 if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
  51                         spin_unlock(&inode->i_lock);
  52                         continue;
  53                 }
  54
  55                 /*
  56                  * If i_count is zero, the inode cannot have any watches and
  57                  * doing an __iget/iput with SB_ACTIVE clear would actually
  58                  * evict all inodes with zero i_count from icache which is
  59                  * unnecessarily violent and may in fact be illegal to do.
  60                  * However, we should have been called /after/ evict_inodes
  61                  * removed all zero refcount inodes, in any case.  Test to
  62                  * be sure.
  63                  */
  64                 if (!atomic_read(&inode->i_count)) {
  65                         spin_unlock(&inode->i_lock);
  66                         continue;
  67                 }
  68
  69                 __iget(inode);
  70                 spin_unlock(&inode->i_lock);
  71                 spin_unlock(&sb->s_inode_list_lock);
  72
  73                 iput(iput_inode);
  74
  75                 /* for each watch, send FS_UNMOUNT and then remove it */
  76                 fsnotify_inode(inode, FS_UNMOUNT);
  77
  78                 fsnotify_inode_delete(inode);
  79
  80                 iput_inode = inode;
  81
  82                 cond_resched();
  83                 spin_lock(&sb->s_inode_list_lock);
  84         }
  85         spin_unlock(&sb->s_inode_list_lock);
  86
  87         iput(iput_inode);
  88 }
  89
  90 void fsnotify_sb_delete(struct super_block *sb)
  91 {
  92         fsnotify_unmount_inodes(sb);
  93         fsnotify_clear_marks_by_sb(sb);
  94         /* Wait for outstanding object references from connectors */
  95         wait_var_event(&sb->s_fsnotify_connectors,
  96                        !atomic_long_read(&sb->s_fsnotify_connectors));
  97 }
  98
  99 /*
 100  * Given an inode, first check if we care what happens to our children.  Inotify
 101  * and dnotify both tell their parents about events.  If we care about any event
 102  * on a child we run all of our children and set a dentry flag saying that the
 103  * parent cares.  Thus when an event happens on a child it can quickly tell
 104  * if there is a need to find a parent and send the event to the parent.
 105  */
 106 void __fsnotify_update_child_dentry_flags(struct inode *inode)
 107 {
 108         struct dentry *alias;
 109         int watched;
 110
 111         if (!S_ISDIR(inode->i_mode))
 112                 return;
 113
 114         /* determine if the children should tell inode about their events */
 115         watched = fsnotify_inode_watches_children(inode);
 116
 117         spin_lock(&inode->i_lock);
 118         /* run all of the dentries associated with this inode.  Since this is a
 119          * directory, there damn well better only be one item on this list */
 120         hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
 121                 struct dentry *child;
 122
 123                 /* run all of the children of the original inode and fix their
 124                  * d_flags to indicate parental interest (their parent is the
 125                  * original inode) */
 126                 spin_lock(&alias->d_lock);
 127                 hlist_for_each_entry(child, &alias->d_children, d_sib) {
 128                         if (!child->d_inode)
 129                                 continue;
 130
 131                         spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
 132                         if (watched)
 133                                 child->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
 134                         else
 135                                 child->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;
 136                         spin_unlock(&child->d_lock);
 137                 }
 138                 spin_unlock(&alias->d_lock);
 139         }
 140         spin_unlock(&inode->i_lock);
 141 }
 142
 143 /* Are inode/sb/mount interested in parent and name info with this event? */
 144 static bool fsnotify_event_needs_parent(struct inode *inode, __u32 mnt_mask,
 145                                         __u32 mask)
 146 {
 147         __u32 marks_mask = 0;
 148
 149         /* We only send parent/name to inode/sb/mount for events on non-dir */
 150         if (mask & FS_ISDIR)
 151                 return false;
 152
 153         /*
 154          * All events that are possible on child can also may be reported with
 155          * parent/name info to inode/sb/mount.  Otherwise, a watching parent
 156          * could result in events reported with unexpected name info to sb/mount.
 157          */
 158         BUILD_BUG_ON(FS_EVENTS_POSS_ON_CHILD & ~FS_EVENTS_POSS_TO_PARENT);
 159
 160         /* Did either inode/sb/mount subscribe for events with parent/name? */
 161         marks_mask |= fsnotify_parent_needed_mask(inode->i_fsnotify_mask);
 162         marks_mask |= fsnotify_parent_needed_mask(inode->i_sb->s_fsnotify_mask);
 163         marks_mask |= fsnotify_parent_needed_mask(mnt_mask);
 164
 165         /* Did they subscribe for this event with parent/name info? */
 166         return mask & marks_mask;
 167 }
 168
 169 /* Are there any inode/mount/sb objects that are interested in this event? */
 170 static inline bool fsnotify_object_watched(struct inode *inode, __u32 mnt_mask,
 171                                            __u32 mask)
 172 {
 173         __u32 marks_mask = inode->i_fsnotify_mask | mnt_mask |
 174                            inode->i_sb->s_fsnotify_mask;
 175
 176         return mask & marks_mask & ALL_FSNOTIFY_EVENTS;
 177 }
 178
 179 /*
 180  * Notify this dentry's parent about a child's events with child name info
 181  * if parent is watching or if inode/sb/mount are interested in events with
 182  * parent and name info.
 183  *
 184  * Notify only the child without name info if parent is not watching and
 185  * inode/sb/mount are not interested in events with parent and name info.
 186  */
 187 int __fsnotify_parent(struct dentry *dentry, __u32 mask, const void *data,
 188                       int data_type)
 189 {
 190         const struct path *path = fsnotify_data_path(data, data_type);
 191         __u32 mnt_mask = path ? real_mount(path->mnt)->mnt_fsnotify_mask : 0;
 192         struct inode *inode = d_inode(dentry);
 193         struct dentry *parent;
 194         bool parent_watched = dentry->d_flags & DCACHE_FSNOTIFY_PARENT_WATCHED;
 195         bool parent_needed, parent_interested;
 196         __u32 p_mask;
 197         struct inode *p_inode = NULL;
 198         struct name_snapshot name;
 199         struct qstr *file_name = NULL;
 200         int ret = 0;
 201
 202         /* Optimize the likely case of nobody watching this path */
 203         if (likely(!parent_watched &&
 204                    !fsnotify_object_watched(inode, mnt_mask, mask)))
 205                 return 0;
 206
 207         parent = NULL;
 208         parent_needed = fsnotify_event_needs_parent(inode, mnt_mask, mask);
 209         if (!parent_watched && !parent_needed)
 210                 goto notify;
 211
 212         /* Does parent inode care about events on children? */
 213         parent = dget_parent(dentry);
 214         p_inode = parent->d_inode;
 215         p_mask = fsnotify_inode_watches_children(p_inode);
 216         if (unlikely(parent_watched && !p_mask))
 217                 __fsnotify_update_child_dentry_flags(p_inode);
 218
 219         /*
 220          * Include parent/name in notification either if some notification
 221          * groups require parent info or the parent is interested in this event.
 222          */
 223         parent_interested = mask & p_mask & ALL_FSNOTIFY_EVENTS;
 224         if (parent_needed || parent_interested) {
 225                 /* When notifying parent, child should be passed as data */
 226                 WARN_ON_ONCE(inode != fsnotify_data_inode(data, data_type));
 227
 228                 /* Notify both parent and child with child name info */
 229                 take_dentry_name_snapshot(&name, dentry);
 230                 file_name = &name.name;
 231                 if (parent_interested)
 232                         mask |= FS_EVENT_ON_CHILD;
 233         }
 234
 235 notify:
 236         ret = fsnotify(mask, data, data_type, p_inode, file_name, inode, 0);
 237
 238         if (file_name)
 239                 release_dentry_name_snapshot(&name);
 240         dput(parent);
 241
 242         return ret;
 243 }
 244 EXPORT_SYMBOL_GPL(__fsnotify_parent);
 245
 246 static int fsnotify_handle_inode_event(struct fsnotify_group *group,
 247                                        struct fsnotify_mark *inode_mark,
 248                                        u32 mask, const void *data, int data_type,
 249                                        struct inode *dir, const struct qstr *name,
 250                                        u32 cookie)
 251 {
 252         const struct path *path = fsnotify_data_path(data, data_type);
 253         struct inode *inode = fsnotify_data_inode(data, data_type);
 254         const struct fsnotify_ops *ops = group->ops;
 255
 256         if (WARN_ON_ONCE(!ops->handle_inode_event))
 257                 return 0;
 258
 259         if (WARN_ON_ONCE(!inode && !dir))
 260                 return 0;
 261
 262         if ((inode_mark->flags & FSNOTIFY_MARK_FLAG_EXCL_UNLINK) &&
 263             path && d_unlinked(path->dentry))
 264                 return 0;
 265
 266         /* Check interest of this mark in case event was sent with two marks */
 267         if (!(mask & inode_mark->mask & ALL_FSNOTIFY_EVENTS))
 268                 return 0;
 269
 270         return ops->handle_inode_event(inode_mark, mask, inode, dir, name, cookie);
 271 }
 272
 273 static int fsnotify_handle_event(struct fsnotify_group *group, __u32 mask,
 274                                  const void *data, int data_type,
 275                                  struct inode *dir, const struct qstr *name,
 276                                  u32 cookie, struct fsnotify_iter_info *iter_info)
 277 {
 278         struct fsnotify_mark *inode_mark = fsnotify_iter_inode_mark(iter_info);
 279         struct fsnotify_mark *parent_mark = fsnotify_iter_parent_mark(iter_info);
 280         int ret;
 281
 282         if (WARN_ON_ONCE(fsnotify_iter_sb_mark(iter_info)) ||
 283             WARN_ON_ONCE(fsnotify_iter_vfsmount_mark(iter_info)))
 284                 return 0;
 285
 286         /*
 287          * For FS_RENAME, 'dir' is old dir and 'data' is new dentry.
 288          * The only ->handle_inode_event() backend that supports FS_RENAME is
 289          * dnotify, where it means file was renamed within same parent.
 290          */
 291         if (mask & FS_RENAME) {
 292                 struct dentry *moved = fsnotify_data_dentry(data, data_type);
 293
 294                 if (dir != moved->d_parent->d_inode)
 295                         return 0;
 296         }
 297
 298         if (parent_mark) {
 299                 ret = fsnotify_handle_inode_event(group, parent_mark, mask,
 300                                                   data, data_type, dir, name, 0);
 301                 if (ret)
 302                         return ret;
 303         }
 304
 305         if (!inode_mark)
 306                 return 0;
 307
 308         if (mask & FS_EVENT_ON_CHILD) {
 309                 /*
 310                  * Some events can be sent on both parent dir and child marks
 311                  * (e.g. FS_ATTRIB).  If both parent dir and child are
 312                  * watching, report the event once to parent dir with name (if
 313                  * interested) and once to child without name (if interested).
 314                  * The child watcher is expecting an event without a file name
 315                  * and without the FS_EVENT_ON_CHILD flag.
 316                  */
 317                 mask &= ~FS_EVENT_ON_CHILD;
 318                 dir = NULL;
 319                 name = NULL;
 320         }
 321
 322         return fsnotify_handle_inode_event(group, inode_mark, mask, data, data_type,
 323                                            dir, name, cookie);
 324 }
 325
 326 static int send_to_group(__u32 mask, const void *data, int data_type,
 327                          struct inode *dir, const struct qstr *file_name,
 328                          u32 cookie, struct fsnotify_iter_info *iter_info)
 329 {
 330         struct fsnotify_group *group = NULL;
 331         __u32 test_mask = (mask & ALL_FSNOTIFY_EVENTS);
 332         __u32 marks_mask = 0;
 333         __u32 marks_ignore_mask = 0;
 334         bool is_dir = mask & FS_ISDIR;
 335         struct fsnotify_mark *mark;
 336         int type;
 337
 338         if (!iter_info->report_mask)
 339                 return 0;
 340
 341         /* clear ignored on inode modification */
 342         if (mask & FS_MODIFY) {
 343                 fsnotify_foreach_iter_mark_type(iter_info, mark, type) {
 344                         if (!(mark->flags &
 345                               FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY))
 346                                 mark->ignore_mask = 0;
 347                 }
 348         }
 349
 350         /* Are any of the group marks interested in this event? */
 351         fsnotify_foreach_iter_mark_type(iter_info, mark, type) {
 352                 group = mark->group;
 353                 marks_mask |= mark->mask;
 354                 marks_ignore_mask |=
 355                         fsnotify_effective_ignore_mask(mark, is_dir, type);
 356         }
 357
 358         pr_debug("%s: group=%p mask=%x marks_mask=%x marks_ignore_mask=%x data=%p data_type=%d dir=%p cookie=%d\n",
 359                  __func__, group, mask, marks_mask, marks_ignore_mask,
 360                  data, data_type, dir, cookie);
 361
 362         if (!(test_mask & marks_mask & ~marks_ignore_mask))
 363                 return 0;
 364
 365         if (group->ops->handle_event) {
 366                 return group->ops->handle_event(group, mask, data, data_type, dir,
 367                                                 file_name, cookie, iter_info);
 368         }
 369
 370         return fsnotify_handle_event(group, mask, data, data_type, dir,
 371                                      file_name, cookie, iter_info);
 372 }
 373
 374 static struct fsnotify_mark *fsnotify_first_mark(struct fsnotify_mark_connector **connp)
 375 {
 376         struct fsnotify_mark_connector *conn;
 377         struct hlist_node *node = NULL;
 378
 379         conn = srcu_dereference(*connp, &fsnotify_mark_srcu);
 380         if (conn)
 381                 node = srcu_dereference(conn->list.first, &fsnotify_mark_srcu);
 382
 383         return hlist_entry_safe(node, struct fsnotify_mark, obj_list);
 384 }
 385
 386 static struct fsnotify_mark *fsnotify_next_mark(struct fsnotify_mark *mark)
 387 {
 388         struct hlist_node *node = NULL;
 389
 390         if (mark)
 391                 node = srcu_dereference(mark->obj_list.next,
 392                                         &fsnotify_mark_srcu);
 393
 394         return hlist_entry_safe(node, struct fsnotify_mark, obj_list);
 395 }
 396
 397 /*
 398  * iter_info is a multi head priority queue of marks.
 399  * Pick a subset of marks from queue heads, all with the same group
 400  * and set the report_mask to a subset of the selected marks.
 401  * Returns false if there are no more groups to iterate.
 402  */
 403 static bool fsnotify_iter_select_report_types(
 404                 struct fsnotify_iter_info *iter_info)
 405 {
 406         struct fsnotify_group *max_prio_group = NULL;
 407         struct fsnotify_mark *mark;
 408         int type;
 409
 410         /* Choose max prio group among groups of all queue heads */
 411         fsnotify_foreach_iter_type(type) {
 412                 mark = iter_info->marks[type];
 413                 if (mark &&
 414                     fsnotify_compare_groups(max_prio_group, mark->group) > 0)
 415                         max_prio_group = mark->group;
 416         }
 417
 418         if (!max_prio_group)
 419                 return false;
 420
 421         /* Set the report mask for marks from same group as max prio group */
 422         iter_info->current_group = max_prio_group;
 423         iter_info->report_mask = 0;
 424         fsnotify_foreach_iter_type(type) {
 425                 mark = iter_info->marks[type];
 426                 if (mark && mark->group == iter_info->current_group) {
 427                         /*
 428                          * FSNOTIFY_ITER_TYPE_PARENT indicates that this inode
 429                          * is watching children and interested in this event,
 430                          * which is an event possible on child.
 431                          * But is *this mark* watching children?
 432                          */
 433                         if (type == FSNOTIFY_ITER_TYPE_PARENT &&
 434                             !(mark->mask & FS_EVENT_ON_CHILD) &&
 435                             !(fsnotify_ignore_mask(mark) & FS_EVENT_ON_CHILD))
 436                                 continue;
 437
 438                         fsnotify_iter_set_report_type(iter_info, type);
 439                 }
 440         }
 441
 442         return true;
 443 }
 444
 445 /*
 446  * Pop from iter_info multi head queue, the marks that belong to the group of
 447  * current iteration step.
 448  */
 449 static void fsnotify_iter_next(struct fsnotify_iter_info *iter_info)
 450 {
 451         struct fsnotify_mark *mark;
 452         int type;
 453
 454         /*
 455          * We cannot use fsnotify_foreach_iter_mark_type() here because we
 456          * may need to advance a mark of type X that belongs to current_group
 457          * but was not selected for reporting.
 458          */
 459         fsnotify_foreach_iter_type(type) {
 460                 mark = iter_info->marks[type];
 461                 if (mark && mark->group == iter_info->current_group)
 462                         iter_info->marks[type] =
 463                                 fsnotify_next_mark(iter_info->marks[type]);
 464         }
 465 }
 466
 467 /*
 468  * fsnotify - This is the main call to fsnotify.
 469  *
 470  * The VFS calls into hook specific functions in linux/fsnotify.h.
 471  * Those functions then in turn call here.  Here will call out to all of the
 472  * registered fsnotify_group.  Those groups can then use the notification event
 473  * in whatever means they feel necessary.
 474  *
 475  * @mask:       event type and flags
 476  * @data:       object that event happened on
 477  * @data_type:  type of object for fanotify_data_XXX() accessors
 478  * @dir:        optional directory associated with event -
 479  *              if @file_name is not NULL, this is the directory that
 480  *              @file_name is relative to
 481  * @file_name:  optional file name associated with event
 482  * @inode:      optional inode associated with event -
 483  *              If @dir and @inode are both non-NULL, event may be
 484  *              reported to both.
 485  * @cookie:     inotify rename cookie
 486  */
 487 int fsnotify(__u32 mask, const void *data, int data_type, struct inode *dir,
 488              const struct qstr *file_name, struct inode *inode, u32 cookie)
 489 {
 490         const struct path *path = fsnotify_data_path(data, data_type);
 491         struct super_block *sb = fsnotify_data_sb(data, data_type);
 492         struct fsnotify_iter_info iter_info = {};
 493         struct mount *mnt = NULL;
 494         struct inode *inode2 = NULL;
 495         struct dentry *moved;
 496         int inode2_type;
 497         int ret = 0;
 498         __u32 test_mask, marks_mask;
 499
 500         if (path)
 501                 mnt = real_mount(path->mnt);
 502
 503         if (!inode) {
 504                 /* Dirent event - report on TYPE_INODE to dir */
 505                 inode = dir;
 506                 /* For FS_RENAME, inode is old_dir and inode2 is new_dir */
 507                 if (mask & FS_RENAME) {
 508                         moved = fsnotify_data_dentry(data, data_type);
 509                         inode2 = moved->d_parent->d_inode;
 510                         inode2_type = FSNOTIFY_ITER_TYPE_INODE2;
 511                 }
 512         } else if (mask & FS_EVENT_ON_CHILD) {
 513                 /*
 514                  * Event on child - report on TYPE_PARENT to dir if it is
 515                  * watching children and on TYPE_INODE to child.
 516                  */
 517                 inode2 = dir;
 518                 inode2_type = FSNOTIFY_ITER_TYPE_PARENT;
 519         }
 520
 521         /*
 522          * Optimization: srcu_read_lock() has a memory barrier which can
 523          * be expensive.  It protects walking the *_fsnotify_marks lists.
 524          * However, if we do not walk the lists, we do not have to do
 525          * SRCU because we have no references to any objects and do not
 526          * need SRCU to keep them "alive".
 527          */
 528         if (!sb->s_fsnotify_marks &&
 529             (!mnt || !mnt->mnt_fsnotify_marks) &&
 530             (!inode || !inode->i_fsnotify_marks) &&
 531             (!inode2 || !inode2->i_fsnotify_marks))
 532                 return 0;
 533
 534         marks_mask = sb->s_fsnotify_mask;
 535         if (mnt)
 536                 marks_mask |= mnt->mnt_fsnotify_mask;
 537         if (inode)
 538                 marks_mask |= inode->i_fsnotify_mask;
 539         if (inode2)
 540                 marks_mask |= inode2->i_fsnotify_mask;
 541
 542
 543         /*
 544          * If this is a modify event we may need to clear some ignore masks.
 545          * In that case, the object with ignore masks will have the FS_MODIFY
 546          * event in its mask.
 547          * Otherwise, return if none of the marks care about this type of event.
 548          */
 549         test_mask = (mask & ALL_FSNOTIFY_EVENTS);
 550         if (!(test_mask & marks_mask))
 551                 return 0;
 552
 553         iter_info.srcu_idx = srcu_read_lock(&fsnotify_mark_srcu);
 554
 555         iter_info.marks[FSNOTIFY_ITER_TYPE_SB] =
 556                 fsnotify_first_mark(&sb->s_fsnotify_marks);
 557         if (mnt) {
 558                 iter_info.marks[FSNOTIFY_ITER_TYPE_VFSMOUNT] =
 559                         fsnotify_first_mark(&mnt->mnt_fsnotify_marks);
 560         }
 561         if (inode) {
 562                 iter_info.marks[FSNOTIFY_ITER_TYPE_INODE] =
 563                         fsnotify_first_mark(&inode->i_fsnotify_marks);
 564         }
 565         if (inode2) {
 566                 iter_info.marks[inode2_type] =
 567                         fsnotify_first_mark(&inode2->i_fsnotify_marks);
 568         }
 569
 570         /*
 571          * We need to merge inode/vfsmount/sb mark lists so that e.g. inode mark
 572          * ignore masks are properly reflected for mount/sb mark notifications.
 573          * That's why this traversal is so complicated...
 574          */
 575         while (fsnotify_iter_select_report_types(&iter_info)) {
 576                 ret = send_to_group(mask, data, data_type, dir, file_name,
 577                                     cookie, &iter_info);
 578
 579                 if (ret && (mask & ALL_FSNOTIFY_PERM_EVENTS))
 580                         goto out;
 581
 582                 fsnotify_iter_next(&iter_info);
 583         }
 584         ret = 0;
 585 out:
 586         srcu_read_unlock(&fsnotify_mark_srcu, iter_info.srcu_idx);
 587
 588         return ret;
 589 }
 590 EXPORT_SYMBOL_GPL(fsnotify);
 591
 592 static __init int fsnotify_init(void)
 593 {
 594         int ret;
 595
 596         BUILD_BUG_ON(HWEIGHT32(ALL_FSNOTIFY_BITS) != 23);
 597
 598         ret = init_srcu_struct(&fsnotify_mark_srcu);
 599         if (ret)
 600                 panic("initializing fsnotify_mark_srcu");
 601
 602         fsnotify_mark_connector_cachep = KMEM_CACHE(fsnotify_mark_connector,
 603                                                     SLAB_PANIC);
 604
 605         return 0;
 606 }
 607 core_initcall(fsnotify_init);