1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #include <linux/fsnotify_backend.h> 3 #include <linux/path.h> 4 #include <linux/slab.h> 5 #include <linux/exportfs.h> 6 #include <linux/hashtable.h> 7 8 extern struct kmem_cache *fanotify_mark_cache; 9 extern struct kmem_cache *fanotify_fid_event_cachep; 10 extern struct kmem_cache *fanotify_path_event_cachep; 11 extern struct kmem_cache *fanotify_perm_event_cachep; 12 13 /* Possible states of the permission event */ 14 enum { 15 FAN_EVENT_INIT, 16 FAN_EVENT_REPORTED, 17 FAN_EVENT_ANSWERED, 18 FAN_EVENT_CANCELED, 19 }; 20 21 /* 22 * 3 dwords are sufficient for most local fs (64bit ino, 32bit generation). 23 * fh buf should be dword aligned. On 64bit arch, the ext_buf pointer is 24 * stored in either the first or last 2 dwords. 25 */ 26 #define FANOTIFY_INLINE_FH_LEN (3 << 2) 27 #define FANOTIFY_FH_HDR_LEN offsetof(struct fanotify_fh, buf) 28 29 /* Fixed size struct for file handle */ 30 struct fanotify_fh { 31 u8 type; 32 u8 len; 33 #define FANOTIFY_FH_FLAG_EXT_BUF 1 34 u8 flags; 35 u8 pad; 36 unsigned char buf[]; 37 } __aligned(4); 38 39 /* Variable size struct for dir file handle + child file handle + name */ 40 struct fanotify_info { 41 /* size of dir_fh/file_fh including fanotify_fh hdr size */ 42 u8 dir_fh_totlen; 43 u8 dir2_fh_totlen; 44 u8 file_fh_totlen; 45 u8 name_len; 46 u8 name2_len; 47 u8 pad[3]; 48 unsigned char buf[]; 49 /* 50 * (struct fanotify_fh) dir_fh starts at buf[0] 51 * (optional) dir2_fh starts at buf[dir_fh_totlen] 52 * (optional) file_fh starts at buf[dir_fh_totlen + dir2_fh_totlen] 53 * name starts at buf[dir_fh_totlen + dir2_fh_totlen + file_fh_totlen] 54 * ... 55 */ 56 #define FANOTIFY_DIR_FH_SIZE(info) ((info)->dir_fh_totlen) 57 #define FANOTIFY_DIR2_FH_SIZE(info) ((info)->dir2_fh_totlen) 58 #define FANOTIFY_FILE_FH_SIZE(info) ((info)->file_fh_totlen) 59 #define FANOTIFY_NAME_SIZE(info) ((info)->name_len + 1) 60 #define FANOTIFY_NAME2_SIZE(info) ((info)->name2_len + 1) 61 62 #define FANOTIFY_DIR_FH_OFFSET(info) 0 63 #define FANOTIFY_DIR2_FH_OFFSET(info) \ 64 (FANOTIFY_DIR_FH_OFFSET(info) + FANOTIFY_DIR_FH_SIZE(info)) 65 #define FANOTIFY_FILE_FH_OFFSET(info) \ 66 (FANOTIFY_DIR2_FH_OFFSET(info) + FANOTIFY_DIR2_FH_SIZE(info)) 67 #define FANOTIFY_NAME_OFFSET(info) \ 68 (FANOTIFY_FILE_FH_OFFSET(info) + FANOTIFY_FILE_FH_SIZE(info)) 69 #define FANOTIFY_NAME2_OFFSET(info) \ 70 (FANOTIFY_NAME_OFFSET(info) + FANOTIFY_NAME_SIZE(info)) 71 72 #define FANOTIFY_DIR_FH_BUF(info) \ 73 ((info)->buf + FANOTIFY_DIR_FH_OFFSET(info)) 74 #define FANOTIFY_DIR2_FH_BUF(info) \ 75 ((info)->buf + FANOTIFY_DIR2_FH_OFFSET(info)) 76 #define FANOTIFY_FILE_FH_BUF(info) \ 77 ((info)->buf + FANOTIFY_FILE_FH_OFFSET(info)) 78 #define FANOTIFY_NAME_BUF(info) \ 79 ((info)->buf + FANOTIFY_NAME_OFFSET(info)) 80 #define FANOTIFY_NAME2_BUF(info) \ 81 ((info)->buf + FANOTIFY_NAME2_OFFSET(info)) 82 } __aligned(4); 83 84 static inline bool fanotify_fh_has_ext_buf(struct fanotify_fh *fh) 85 { 86 return (fh->flags & FANOTIFY_FH_FLAG_EXT_BUF); 87 } 88 89 static inline char **fanotify_fh_ext_buf_ptr(struct fanotify_fh *fh) 90 { 91 BUILD_BUG_ON(FANOTIFY_FH_HDR_LEN % 4); 92 BUILD_BUG_ON(__alignof__(char *) - 4 + sizeof(char *) > 93 FANOTIFY_INLINE_FH_LEN); 94 return (char **)ALIGN((unsigned long)(fh->buf), __alignof__(char *)); 95 } 96 97 static inline void *fanotify_fh_ext_buf(struct fanotify_fh *fh) 98 { 99 return *fanotify_fh_ext_buf_ptr(fh); 100 } 101 102 static inline void *fanotify_fh_buf(struct fanotify_fh *fh) 103 { 104 return fanotify_fh_has_ext_buf(fh) ? fanotify_fh_ext_buf(fh) : fh->buf; 105 } 106 107 static inline int fanotify_info_dir_fh_len(struct fanotify_info *info) 108 { 109 if (!info->dir_fh_totlen || 110 WARN_ON_ONCE(info->dir_fh_totlen < FANOTIFY_FH_HDR_LEN)) 111 return 0; 112 113 return info->dir_fh_totlen - FANOTIFY_FH_HDR_LEN; 114 } 115 116 static inline struct fanotify_fh *fanotify_info_dir_fh(struct fanotify_info *info) 117 { 118 BUILD_BUG_ON(offsetof(struct fanotify_info, buf) % 4); 119 120 return (struct fanotify_fh *)FANOTIFY_DIR_FH_BUF(info); 121 } 122 123 static inline int fanotify_info_dir2_fh_len(struct fanotify_info *info) 124 { 125 if (!info->dir2_fh_totlen || 126 WARN_ON_ONCE(info->dir2_fh_totlen < FANOTIFY_FH_HDR_LEN)) 127 return 0; 128 129 return info->dir2_fh_totlen - FANOTIFY_FH_HDR_LEN; 130 } 131 132 static inline struct fanotify_fh *fanotify_info_dir2_fh(struct fanotify_info *info) 133 { 134 return (struct fanotify_fh *)FANOTIFY_DIR2_FH_BUF(info); 135 } 136 137 static inline int fanotify_info_file_fh_len(struct fanotify_info *info) 138 { 139 if (!info->file_fh_totlen || 140 WARN_ON_ONCE(info->file_fh_totlen < FANOTIFY_FH_HDR_LEN)) 141 return 0; 142 143 return info->file_fh_totlen - FANOTIFY_FH_HDR_LEN; 144 } 145 146 static inline struct fanotify_fh *fanotify_info_file_fh(struct fanotify_info *info) 147 { 148 return (struct fanotify_fh *)FANOTIFY_FILE_FH_BUF(info); 149 } 150 151 static inline char *fanotify_info_name(struct fanotify_info *info) 152 { 153 if (!info->name_len) 154 return NULL; 155 156 return FANOTIFY_NAME_BUF(info); 157 } 158 159 static inline char *fanotify_info_name2(struct fanotify_info *info) 160 { 161 if (!info->name2_len) 162 return NULL; 163 164 return FANOTIFY_NAME2_BUF(info); 165 } 166 167 static inline void fanotify_info_init(struct fanotify_info *info) 168 { 169 BUILD_BUG_ON(FANOTIFY_FH_HDR_LEN + MAX_HANDLE_SZ > U8_MAX); 170 BUILD_BUG_ON(NAME_MAX > U8_MAX); 171 172 info->dir_fh_totlen = 0; 173 info->dir2_fh_totlen = 0; 174 info->file_fh_totlen = 0; 175 info->name_len = 0; 176 info->name2_len = 0; 177 } 178 179 /* These set/copy helpers MUST be called by order */ 180 static inline void fanotify_info_set_dir_fh(struct fanotify_info *info, 181 unsigned int totlen) 182 { 183 if (WARN_ON_ONCE(info->dir2_fh_totlen > 0) || 184 WARN_ON_ONCE(info->file_fh_totlen > 0) || 185 WARN_ON_ONCE(info->name_len > 0) || 186 WARN_ON_ONCE(info->name2_len > 0)) 187 return; 188 189 info->dir_fh_totlen = totlen; 190 } 191 192 static inline void fanotify_info_set_dir2_fh(struct fanotify_info *info, 193 unsigned int totlen) 194 { 195 if (WARN_ON_ONCE(info->file_fh_totlen > 0) || 196 WARN_ON_ONCE(info->name_len > 0) || 197 WARN_ON_ONCE(info->name2_len > 0)) 198 return; 199 200 info->dir2_fh_totlen = totlen; 201 } 202 203 static inline void fanotify_info_set_file_fh(struct fanotify_info *info, 204 unsigned int totlen) 205 { 206 if (WARN_ON_ONCE(info->name_len > 0) || 207 WARN_ON_ONCE(info->name2_len > 0)) 208 return; 209 210 info->file_fh_totlen = totlen; 211 } 212 213 static inline void fanotify_info_copy_name(struct fanotify_info *info, 214 const struct qstr *name) 215 { 216 if (WARN_ON_ONCE(name->len > NAME_MAX) || 217 WARN_ON_ONCE(info->name2_len > 0)) 218 return; 219 220 info->name_len = name->len; 221 strcpy(fanotify_info_name(info), name->name); 222 } 223 224 static inline void fanotify_info_copy_name2(struct fanotify_info *info, 225 const struct qstr *name) 226 { 227 if (WARN_ON_ONCE(name->len > NAME_MAX)) 228 return; 229 230 info->name2_len = name->len; 231 strcpy(fanotify_info_name2(info), name->name); 232 } 233 234 /* 235 * Common structure for fanotify events. Concrete structs are allocated in 236 * fanotify_handle_event() and freed when the information is retrieved by 237 * userspace. The type of event determines how it was allocated, how it will 238 * be freed and which concrete struct it may be cast to. 239 */ 240 enum fanotify_event_type { 241 FANOTIFY_EVENT_TYPE_FID, /* fixed length */ 242 FANOTIFY_EVENT_TYPE_FID_NAME, /* variable length */ 243 FANOTIFY_EVENT_TYPE_PATH, 244 FANOTIFY_EVENT_TYPE_PATH_PERM, 245 FANOTIFY_EVENT_TYPE_OVERFLOW, /* struct fanotify_event */ 246 FANOTIFY_EVENT_TYPE_FS_ERROR, /* struct fanotify_error_event */ 247 __FANOTIFY_EVENT_TYPE_NUM 248 }; 249 250 #define FANOTIFY_EVENT_TYPE_BITS \ 251 (ilog2(__FANOTIFY_EVENT_TYPE_NUM - 1) + 1) 252 #define FANOTIFY_EVENT_HASH_BITS \ 253 (32 - FANOTIFY_EVENT_TYPE_BITS) 254 255 struct fanotify_event { 256 struct fsnotify_event fse; 257 struct hlist_node merge_list; /* List for hashed merge */ 258 u32 mask; 259 struct { 260 unsigned int type : FANOTIFY_EVENT_TYPE_BITS; 261 unsigned int hash : FANOTIFY_EVENT_HASH_BITS; 262 }; 263 struct pid *pid; 264 }; 265 266 static inline void fanotify_init_event(struct fanotify_event *event, 267 unsigned int hash, u32 mask) 268 { 269 fsnotify_init_event(&event->fse); 270 INIT_HLIST_NODE(&event->merge_list); 271 event->hash = hash; 272 event->mask = mask; 273 event->pid = NULL; 274 } 275 276 #define FANOTIFY_INLINE_FH(name, size) \ 277 struct { \ 278 struct fanotify_fh (name); \ 279 /* Space for object_fh.buf[] - access with fanotify_fh_buf() */ \ 280 unsigned char _inline_fh_buf[(size)]; \ 281 } 282 283 struct fanotify_fid_event { 284 struct fanotify_event fae; 285 __kernel_fsid_t fsid; 286 287 FANOTIFY_INLINE_FH(object_fh, FANOTIFY_INLINE_FH_LEN); 288 }; 289 290 static inline struct fanotify_fid_event * 291 FANOTIFY_FE(struct fanotify_event *event) 292 { 293 return container_of(event, struct fanotify_fid_event, fae); 294 } 295 296 struct fanotify_name_event { 297 struct fanotify_event fae; 298 __kernel_fsid_t fsid; 299 struct fanotify_info info; 300 }; 301 302 static inline struct fanotify_name_event * 303 FANOTIFY_NE(struct fanotify_event *event) 304 { 305 return container_of(event, struct fanotify_name_event, fae); 306 } 307 308 struct fanotify_error_event { 309 struct fanotify_event fae; 310 s32 error; /* Error reported by the Filesystem. */ 311 u32 err_count; /* Suppressed errors count */ 312 313 __kernel_fsid_t fsid; /* FSID this error refers to. */ 314 315 FANOTIFY_INLINE_FH(object_fh, MAX_HANDLE_SZ); 316 }; 317 318 static inline struct fanotify_error_event * 319 FANOTIFY_EE(struct fanotify_event *event) 320 { 321 return container_of(event, struct fanotify_error_event, fae); 322 } 323 324 static inline __kernel_fsid_t *fanotify_event_fsid(struct fanotify_event *event) 325 { 326 if (event->type == FANOTIFY_EVENT_TYPE_FID) 327 return &FANOTIFY_FE(event)->fsid; 328 else if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME) 329 return &FANOTIFY_NE(event)->fsid; 330 else if (event->type == FANOTIFY_EVENT_TYPE_FS_ERROR) 331 return &FANOTIFY_EE(event)->fsid; 332 else 333 return NULL; 334 } 335 336 static inline struct fanotify_fh *fanotify_event_object_fh( 337 struct fanotify_event *event) 338 { 339 if (event->type == FANOTIFY_EVENT_TYPE_FID) 340 return &FANOTIFY_FE(event)->object_fh; 341 else if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME) 342 return fanotify_info_file_fh(&FANOTIFY_NE(event)->info); 343 else if (event->type == FANOTIFY_EVENT_TYPE_FS_ERROR) 344 return &FANOTIFY_EE(event)->object_fh; 345 else 346 return NULL; 347 } 348 349 static inline struct fanotify_info *fanotify_event_info( 350 struct fanotify_event *event) 351 { 352 if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME) 353 return &FANOTIFY_NE(event)->info; 354 else 355 return NULL; 356 } 357 358 static inline int fanotify_event_object_fh_len(struct fanotify_event *event) 359 { 360 struct fanotify_info *info = fanotify_event_info(event); 361 struct fanotify_fh *fh = fanotify_event_object_fh(event); 362 363 if (info) 364 return info->file_fh_totlen ? fh->len : 0; 365 else 366 return fh ? fh->len : 0; 367 } 368 369 static inline int fanotify_event_dir_fh_len(struct fanotify_event *event) 370 { 371 struct fanotify_info *info = fanotify_event_info(event); 372 373 return info ? fanotify_info_dir_fh_len(info) : 0; 374 } 375 376 static inline int fanotify_event_dir2_fh_len(struct fanotify_event *event) 377 { 378 struct fanotify_info *info = fanotify_event_info(event); 379 380 return info ? fanotify_info_dir2_fh_len(info) : 0; 381 } 382 383 static inline bool fanotify_event_has_object_fh(struct fanotify_event *event) 384 { 385 /* For error events, even zeroed fh are reported. */ 386 if (event->type == FANOTIFY_EVENT_TYPE_FS_ERROR) 387 return true; 388 return fanotify_event_object_fh_len(event) > 0; 389 } 390 391 static inline bool fanotify_event_has_dir_fh(struct fanotify_event *event) 392 { 393 return fanotify_event_dir_fh_len(event) > 0; 394 } 395 396 static inline bool fanotify_event_has_dir2_fh(struct fanotify_event *event) 397 { 398 return fanotify_event_dir2_fh_len(event) > 0; 399 } 400 401 static inline bool fanotify_event_has_any_dir_fh(struct fanotify_event *event) 402 { 403 return fanotify_event_has_dir_fh(event) || 404 fanotify_event_has_dir2_fh(event); 405 } 406 407 struct fanotify_path_event { 408 struct fanotify_event fae; 409 struct path path; 410 }; 411 412 static inline struct fanotify_path_event * 413 FANOTIFY_PE(struct fanotify_event *event) 414 { 415 return container_of(event, struct fanotify_path_event, fae); 416 } 417 418 /* 419 * Structure for permission fanotify events. It gets allocated and freed in 420 * fanotify_handle_event() since we wait there for user response. When the 421 * information is retrieved by userspace the structure is moved from 422 * group->notification_list to group->fanotify_data.access_list to wait for 423 * user response. 424 */ 425 struct fanotify_perm_event { 426 struct fanotify_event fae; 427 struct path path; 428 u32 response; /* userspace answer to the event */ 429 unsigned short state; /* state of the event */ 430 int fd; /* fd we passed to userspace for this event */ 431 union { 432 struct fanotify_response_info_header hdr; 433 struct fanotify_response_info_audit_rule audit_rule; 434 }; 435 }; 436 437 static inline struct fanotify_perm_event * 438 FANOTIFY_PERM(struct fanotify_event *event) 439 { 440 return container_of(event, struct fanotify_perm_event, fae); 441 } 442 443 static inline bool fanotify_is_perm_event(u32 mask) 444 { 445 return IS_ENABLED(CONFIG_FANOTIFY_ACCESS_PERMISSIONS) && 446 mask & FANOTIFY_PERM_EVENTS; 447 } 448 449 static inline struct fanotify_event *FANOTIFY_E(struct fsnotify_event *fse) 450 { 451 return container_of(fse, struct fanotify_event, fse); 452 } 453 454 static inline bool fanotify_is_error_event(u32 mask) 455 { 456 return mask & FAN_FS_ERROR; 457 } 458 459 static inline const struct path *fanotify_event_path(struct fanotify_event *event) 460 { 461 if (event->type == FANOTIFY_EVENT_TYPE_PATH) 462 return &FANOTIFY_PE(event)->path; 463 else if (event->type == FANOTIFY_EVENT_TYPE_PATH_PERM) 464 return &FANOTIFY_PERM(event)->path; 465 else 466 return NULL; 467 } 468 469 /* 470 * Use 128 size hash table to speed up events merge. 471 */ 472 #define FANOTIFY_HTABLE_BITS (7) 473 #define FANOTIFY_HTABLE_SIZE (1 << FANOTIFY_HTABLE_BITS) 474 #define FANOTIFY_HTABLE_MASK (FANOTIFY_HTABLE_SIZE - 1) 475 476 /* 477 * Permission events and overflow event do not get merged - don't hash them. 478 */ 479 static inline bool fanotify_is_hashed_event(u32 mask) 480 { 481 return !(fanotify_is_perm_event(mask) || 482 fsnotify_is_overflow_event(mask)); 483 } 484 485 static inline unsigned int fanotify_event_hash_bucket( 486 struct fsnotify_group *group, 487 struct fanotify_event *event) 488 { 489 return event->hash & FANOTIFY_HTABLE_MASK; 490 } 491 492 static inline unsigned int fanotify_mark_user_flags(struct fsnotify_mark *mark) 493 { 494 unsigned int mflags = 0; 495 496 if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY) 497 mflags |= FAN_MARK_IGNORED_SURV_MODIFY; 498 if (mark->flags & FSNOTIFY_MARK_FLAG_NO_IREF) 499 mflags |= FAN_MARK_EVICTABLE; 500 if (mark->flags & FSNOTIFY_MARK_FLAG_HAS_IGNORE_FLAGS) 501 mflags |= FAN_MARK_IGNORE; 502 503 return mflags; 504 } 505