1 /* 2 * Directory notifications for Linux. 3 * 4 * Copyright (C) 2000,2001,2002 Stephen Rothwell 5 * 6 * Copyright (C) 2009 Eric Paris <Red Hat Inc> 7 * dnotify was largly rewritten to use the new fsnotify infrastructure 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2, or (at your option) any 12 * later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 */ 19 #include <linux/fs.h> 20 #include <linux/module.h> 21 #include <linux/sched.h> 22 #include <linux/dnotify.h> 23 #include <linux/init.h> 24 #include <linux/spinlock.h> 25 #include <linux/slab.h> 26 #include <linux/fdtable.h> 27 #include <linux/fsnotify_backend.h> 28 29 int dir_notify_enable __read_mostly = 1; 30 31 static struct kmem_cache *dnotify_struct_cache __read_mostly; 32 static struct kmem_cache *dnotify_mark_cache __read_mostly; 33 static struct fsnotify_group *dnotify_group __read_mostly; 34 35 /* 36 * dnotify will attach one of these to each inode (i_fsnotify_marks) which 37 * is being watched by dnotify. If multiple userspace applications are watching 38 * the same directory with dnotify their information is chained in dn 39 */ 40 struct dnotify_mark { 41 struct fsnotify_mark fsn_mark; 42 struct dnotify_struct *dn; 43 }; 44 45 /* 46 * When a process starts or stops watching an inode the set of events which 47 * dnotify cares about for that inode may change. This function runs the 48 * list of everything receiving dnotify events about this directory and calculates 49 * the set of all those events. After it updates what dnotify is interested in 50 * it calls the fsnotify function so it can update the set of all events relevant 51 * to this inode. 52 */ 53 static void dnotify_recalc_inode_mask(struct fsnotify_mark *fsn_mark) 54 { 55 __u32 new_mask = 0; 56 struct dnotify_struct *dn; 57 struct dnotify_mark *dn_mark = container_of(fsn_mark, 58 struct dnotify_mark, 59 fsn_mark); 60 61 assert_spin_locked(&fsn_mark->lock); 62 63 for (dn = dn_mark->dn; dn != NULL; dn = dn->dn_next) 64 new_mask |= (dn->dn_mask & ~FS_DN_MULTISHOT); 65 if (fsn_mark->mask == new_mask) 66 return; 67 fsn_mark->mask = new_mask; 68 69 fsnotify_recalc_mask(fsn_mark->connector); 70 } 71 72 /* 73 * Mains fsnotify call where events are delivered to dnotify. 74 * Find the dnotify mark on the relevant inode, run the list of dnotify structs 75 * on that mark and determine which of them has expressed interest in receiving 76 * events of this type. When found send the correct process and signal and 77 * destroy the dnotify struct if it was not registered to receive multiple 78 * events. 79 */ 80 static int dnotify_handle_event(struct fsnotify_group *group, 81 struct inode *inode, 82 struct fsnotify_mark *inode_mark, 83 struct fsnotify_mark *vfsmount_mark, 84 u32 mask, const void *data, int data_type, 85 const unsigned char *file_name, u32 cookie, 86 struct fsnotify_iter_info *iter_info) 87 { 88 struct dnotify_mark *dn_mark; 89 struct dnotify_struct *dn; 90 struct dnotify_struct **prev; 91 struct fown_struct *fown; 92 __u32 test_mask = mask & ~FS_EVENT_ON_CHILD; 93 94 /* not a dir, dnotify doesn't care */ 95 if (!S_ISDIR(inode->i_mode)) 96 return 0; 97 98 BUG_ON(vfsmount_mark); 99 100 dn_mark = container_of(inode_mark, struct dnotify_mark, fsn_mark); 101 102 spin_lock(&inode_mark->lock); 103 prev = &dn_mark->dn; 104 while ((dn = *prev) != NULL) { 105 if ((dn->dn_mask & test_mask) == 0) { 106 prev = &dn->dn_next; 107 continue; 108 } 109 fown = &dn->dn_filp->f_owner; 110 send_sigio(fown, dn->dn_fd, POLL_MSG); 111 if (dn->dn_mask & FS_DN_MULTISHOT) 112 prev = &dn->dn_next; 113 else { 114 *prev = dn->dn_next; 115 kmem_cache_free(dnotify_struct_cache, dn); 116 dnotify_recalc_inode_mask(inode_mark); 117 } 118 } 119 120 spin_unlock(&inode_mark->lock); 121 122 return 0; 123 } 124 125 static void dnotify_free_mark(struct fsnotify_mark *fsn_mark) 126 { 127 struct dnotify_mark *dn_mark = container_of(fsn_mark, 128 struct dnotify_mark, 129 fsn_mark); 130 131 BUG_ON(dn_mark->dn); 132 133 kmem_cache_free(dnotify_mark_cache, dn_mark); 134 } 135 136 static const struct fsnotify_ops dnotify_fsnotify_ops = { 137 .handle_event = dnotify_handle_event, 138 .free_mark = dnotify_free_mark, 139 }; 140 141 /* 142 * Called every time a file is closed. Looks first for a dnotify mark on the 143 * inode. If one is found run all of the ->dn structures attached to that 144 * mark for one relevant to this process closing the file and remove that 145 * dnotify_struct. If that was the last dnotify_struct also remove the 146 * fsnotify_mark. 147 */ 148 void dnotify_flush(struct file *filp, fl_owner_t id) 149 { 150 struct fsnotify_mark *fsn_mark; 151 struct dnotify_mark *dn_mark; 152 struct dnotify_struct *dn; 153 struct dnotify_struct **prev; 154 struct inode *inode; 155 bool free = false; 156 157 inode = file_inode(filp); 158 if (!S_ISDIR(inode->i_mode)) 159 return; 160 161 fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, dnotify_group); 162 if (!fsn_mark) 163 return; 164 dn_mark = container_of(fsn_mark, struct dnotify_mark, fsn_mark); 165 166 mutex_lock(&dnotify_group->mark_mutex); 167 168 spin_lock(&fsn_mark->lock); 169 prev = &dn_mark->dn; 170 while ((dn = *prev) != NULL) { 171 if ((dn->dn_owner == id) && (dn->dn_filp == filp)) { 172 *prev = dn->dn_next; 173 kmem_cache_free(dnotify_struct_cache, dn); 174 dnotify_recalc_inode_mask(fsn_mark); 175 break; 176 } 177 prev = &dn->dn_next; 178 } 179 180 spin_unlock(&fsn_mark->lock); 181 182 /* nothing else could have found us thanks to the dnotify_groups 183 mark_mutex */ 184 if (dn_mark->dn == NULL) { 185 fsnotify_detach_mark(fsn_mark); 186 free = true; 187 } 188 189 mutex_unlock(&dnotify_group->mark_mutex); 190 191 if (free) 192 fsnotify_free_mark(fsn_mark); 193 fsnotify_put_mark(fsn_mark); 194 } 195 196 /* this conversion is done only at watch creation */ 197 static __u32 convert_arg(unsigned long arg) 198 { 199 __u32 new_mask = FS_EVENT_ON_CHILD; 200 201 if (arg & DN_MULTISHOT) 202 new_mask |= FS_DN_MULTISHOT; 203 if (arg & DN_DELETE) 204 new_mask |= (FS_DELETE | FS_MOVED_FROM); 205 if (arg & DN_MODIFY) 206 new_mask |= FS_MODIFY; 207 if (arg & DN_ACCESS) 208 new_mask |= FS_ACCESS; 209 if (arg & DN_ATTRIB) 210 new_mask |= FS_ATTRIB; 211 if (arg & DN_RENAME) 212 new_mask |= FS_DN_RENAME; 213 if (arg & DN_CREATE) 214 new_mask |= (FS_CREATE | FS_MOVED_TO); 215 216 return new_mask; 217 } 218 219 /* 220 * If multiple processes watch the same inode with dnotify there is only one 221 * dnotify mark in inode->i_fsnotify_marks but we chain a dnotify_struct 222 * onto that mark. This function either attaches the new dnotify_struct onto 223 * that list, or it |= the mask onto an existing dnofiy_struct. 224 */ 225 static int attach_dn(struct dnotify_struct *dn, struct dnotify_mark *dn_mark, 226 fl_owner_t id, int fd, struct file *filp, __u32 mask) 227 { 228 struct dnotify_struct *odn; 229 230 odn = dn_mark->dn; 231 while (odn != NULL) { 232 /* adding more events to existing dnofiy_struct? */ 233 if ((odn->dn_owner == id) && (odn->dn_filp == filp)) { 234 odn->dn_fd = fd; 235 odn->dn_mask |= mask; 236 return -EEXIST; 237 } 238 odn = odn->dn_next; 239 } 240 241 dn->dn_mask = mask; 242 dn->dn_fd = fd; 243 dn->dn_filp = filp; 244 dn->dn_owner = id; 245 dn->dn_next = dn_mark->dn; 246 dn_mark->dn = dn; 247 248 return 0; 249 } 250 251 /* 252 * When a process calls fcntl to attach a dnotify watch to a directory it ends 253 * up here. Allocate both a mark for fsnotify to add and a dnotify_struct to be 254 * attached to the fsnotify_mark. 255 */ 256 int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg) 257 { 258 struct dnotify_mark *new_dn_mark, *dn_mark; 259 struct fsnotify_mark *new_fsn_mark, *fsn_mark; 260 struct dnotify_struct *dn; 261 struct inode *inode; 262 fl_owner_t id = current->files; 263 struct file *f; 264 int destroy = 0, error = 0; 265 __u32 mask; 266 267 /* we use these to tell if we need to kfree */ 268 new_fsn_mark = NULL; 269 dn = NULL; 270 271 if (!dir_notify_enable) { 272 error = -EINVAL; 273 goto out_err; 274 } 275 276 /* a 0 mask means we are explicitly removing the watch */ 277 if ((arg & ~DN_MULTISHOT) == 0) { 278 dnotify_flush(filp, id); 279 error = 0; 280 goto out_err; 281 } 282 283 /* dnotify only works on directories */ 284 inode = file_inode(filp); 285 if (!S_ISDIR(inode->i_mode)) { 286 error = -ENOTDIR; 287 goto out_err; 288 } 289 290 /* expect most fcntl to add new rather than augment old */ 291 dn = kmem_cache_alloc(dnotify_struct_cache, GFP_KERNEL); 292 if (!dn) { 293 error = -ENOMEM; 294 goto out_err; 295 } 296 297 /* new fsnotify mark, we expect most fcntl calls to add a new mark */ 298 new_dn_mark = kmem_cache_alloc(dnotify_mark_cache, GFP_KERNEL); 299 if (!new_dn_mark) { 300 error = -ENOMEM; 301 goto out_err; 302 } 303 304 /* convert the userspace DN_* "arg" to the internal FS_* defines in fsnotify */ 305 mask = convert_arg(arg); 306 307 /* set up the new_fsn_mark and new_dn_mark */ 308 new_fsn_mark = &new_dn_mark->fsn_mark; 309 fsnotify_init_mark(new_fsn_mark, dnotify_group); 310 new_fsn_mark->mask = mask; 311 new_dn_mark->dn = NULL; 312 313 /* this is needed to prevent the fcntl/close race described below */ 314 mutex_lock(&dnotify_group->mark_mutex); 315 316 /* add the new_fsn_mark or find an old one. */ 317 fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, dnotify_group); 318 if (fsn_mark) { 319 dn_mark = container_of(fsn_mark, struct dnotify_mark, fsn_mark); 320 spin_lock(&fsn_mark->lock); 321 } else { 322 error = fsnotify_add_mark_locked(new_fsn_mark, inode, NULL, 0); 323 if (error) { 324 mutex_unlock(&dnotify_group->mark_mutex); 325 goto out_err; 326 } 327 spin_lock(&new_fsn_mark->lock); 328 fsn_mark = new_fsn_mark; 329 dn_mark = new_dn_mark; 330 /* we used new_fsn_mark, so don't free it */ 331 new_fsn_mark = NULL; 332 } 333 334 rcu_read_lock(); 335 f = fcheck(fd); 336 rcu_read_unlock(); 337 338 /* if (f != filp) means that we lost a race and another task/thread 339 * actually closed the fd we are still playing with before we grabbed 340 * the dnotify_groups mark_mutex and fsn_mark->lock. Since closing the 341 * fd is the only time we clean up the marks we need to get our mark 342 * off the list. */ 343 if (f != filp) { 344 /* if we added ourselves, shoot ourselves, it's possible that 345 * the flush actually did shoot this fsn_mark. That's fine too 346 * since multiple calls to destroy_mark is perfectly safe, if 347 * we found a dn_mark already attached to the inode, just sod 348 * off silently as the flush at close time dealt with it. 349 */ 350 if (dn_mark == new_dn_mark) 351 destroy = 1; 352 error = 0; 353 goto out; 354 } 355 356 __f_setown(filp, task_pid(current), PIDTYPE_PID, 0); 357 358 error = attach_dn(dn, dn_mark, id, fd, filp, mask); 359 /* !error means that we attached the dn to the dn_mark, so don't free it */ 360 if (!error) 361 dn = NULL; 362 /* -EEXIST means that we didn't add this new dn and used an old one. 363 * that isn't an error (and the unused dn should be freed) */ 364 else if (error == -EEXIST) 365 error = 0; 366 367 dnotify_recalc_inode_mask(fsn_mark); 368 out: 369 spin_unlock(&fsn_mark->lock); 370 371 if (destroy) 372 fsnotify_detach_mark(fsn_mark); 373 mutex_unlock(&dnotify_group->mark_mutex); 374 if (destroy) 375 fsnotify_free_mark(fsn_mark); 376 fsnotify_put_mark(fsn_mark); 377 out_err: 378 if (new_fsn_mark) 379 fsnotify_put_mark(new_fsn_mark); 380 if (dn) 381 kmem_cache_free(dnotify_struct_cache, dn); 382 return error; 383 } 384 385 static int __init dnotify_init(void) 386 { 387 dnotify_struct_cache = KMEM_CACHE(dnotify_struct, SLAB_PANIC); 388 dnotify_mark_cache = KMEM_CACHE(dnotify_mark, SLAB_PANIC); 389 390 dnotify_group = fsnotify_alloc_group(&dnotify_fsnotify_ops); 391 if (IS_ERR(dnotify_group)) 392 panic("unable to allocate fsnotify group for dnotify\n"); 393 return 0; 394 } 395 396 module_init(dnotify_init) 397