1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/fs/9p/vfs_inode_dotl.c 4 * 5 * This file contains vfs inode ops for the 9P2000.L protocol. 6 * 7 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> 8 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> 9 */ 10 11 #include <linux/module.h> 12 #include <linux/errno.h> 13 #include <linux/fs.h> 14 #include <linux/file.h> 15 #include <linux/pagemap.h> 16 #include <linux/stat.h> 17 #include <linux/string.h> 18 #include <linux/inet.h> 19 #include <linux/namei.h> 20 #include <linux/idr.h> 21 #include <linux/sched.h> 22 #include <linux/slab.h> 23 #include <linux/xattr.h> 24 #include <linux/posix_acl.h> 25 #include <net/9p/9p.h> 26 #include <net/9p/client.h> 27 28 #include "v9fs.h" 29 #include "v9fs_vfs.h" 30 #include "fid.h" 31 #include "cache.h" 32 #include "xattr.h" 33 #include "acl.h" 34 35 static int 36 v9fs_vfs_mknod_dotl(struct user_namespace *mnt_userns, struct inode *dir, 37 struct dentry *dentry, umode_t omode, dev_t rdev); 38 39 /** 40 * v9fs_get_fsgid_for_create - Helper function to get the gid for creating a 41 * new file system object. This checks the S_ISGID to determine the owning 42 * group of the new file system object. 43 */ 44 45 static kgid_t v9fs_get_fsgid_for_create(struct inode *dir_inode) 46 { 47 BUG_ON(dir_inode == NULL); 48 49 if (dir_inode->i_mode & S_ISGID) { 50 /* set_gid bit is set.*/ 51 return dir_inode->i_gid; 52 } 53 return current_fsgid(); 54 } 55 56 static int v9fs_test_inode_dotl(struct inode *inode, void *data) 57 { 58 struct v9fs_inode *v9inode = V9FS_I(inode); 59 struct p9_stat_dotl *st = (struct p9_stat_dotl *)data; 60 61 /* don't match inode of different type */ 62 if ((inode->i_mode & S_IFMT) != (st->st_mode & S_IFMT)) 63 return 0; 64 65 if (inode->i_generation != st->st_gen) 66 return 0; 67 68 /* compare qid details */ 69 if (memcmp(&v9inode->qid.version, 70 &st->qid.version, sizeof(v9inode->qid.version))) 71 return 0; 72 73 if (v9inode->qid.type != st->qid.type) 74 return 0; 75 76 if (v9inode->qid.path != st->qid.path) 77 return 0; 78 return 1; 79 } 80 81 /* Always get a new inode */ 82 static int v9fs_test_new_inode_dotl(struct inode *inode, void *data) 83 { 84 return 0; 85 } 86 87 static int v9fs_set_inode_dotl(struct inode *inode, void *data) 88 { 89 struct v9fs_inode *v9inode = V9FS_I(inode); 90 struct p9_stat_dotl *st = (struct p9_stat_dotl *)data; 91 92 memcpy(&v9inode->qid, &st->qid, sizeof(st->qid)); 93 inode->i_generation = st->st_gen; 94 return 0; 95 } 96 97 static struct inode *v9fs_qid_iget_dotl(struct super_block *sb, 98 struct p9_qid *qid, 99 struct p9_fid *fid, 100 struct p9_stat_dotl *st, 101 int new) 102 { 103 int retval; 104 unsigned long i_ino; 105 struct inode *inode; 106 struct v9fs_session_info *v9ses = sb->s_fs_info; 107 int (*test)(struct inode *, void *); 108 109 if (new) 110 test = v9fs_test_new_inode_dotl; 111 else 112 test = v9fs_test_inode_dotl; 113 114 i_ino = v9fs_qid2ino(qid); 115 inode = iget5_locked(sb, i_ino, test, v9fs_set_inode_dotl, st); 116 if (!inode) 117 return ERR_PTR(-ENOMEM); 118 if (!(inode->i_state & I_NEW)) 119 return inode; 120 /* 121 * initialize the inode with the stat info 122 * FIXME!! we may need support for stale inodes 123 * later. 124 */ 125 inode->i_ino = i_ino; 126 retval = v9fs_init_inode(v9ses, inode, 127 st->st_mode, new_decode_dev(st->st_rdev)); 128 if (retval) 129 goto error; 130 131 v9fs_stat2inode_dotl(st, inode, 0); 132 v9fs_cache_inode_get_cookie(inode); 133 retval = v9fs_get_acl(inode, fid); 134 if (retval) 135 goto error; 136 137 unlock_new_inode(inode); 138 return inode; 139 error: 140 iget_failed(inode); 141 return ERR_PTR(retval); 142 143 } 144 145 struct inode * 146 v9fs_inode_from_fid_dotl(struct v9fs_session_info *v9ses, struct p9_fid *fid, 147 struct super_block *sb, int new) 148 { 149 struct p9_stat_dotl *st; 150 struct inode *inode = NULL; 151 152 st = p9_client_getattr_dotl(fid, P9_STATS_BASIC | P9_STATS_GEN); 153 if (IS_ERR(st)) 154 return ERR_CAST(st); 155 156 inode = v9fs_qid_iget_dotl(sb, &st->qid, fid, st, new); 157 kfree(st); 158 return inode; 159 } 160 161 struct dotl_openflag_map { 162 int open_flag; 163 int dotl_flag; 164 }; 165 166 static int v9fs_mapped_dotl_flags(int flags) 167 { 168 int i; 169 int rflags = 0; 170 struct dotl_openflag_map dotl_oflag_map[] = { 171 { O_CREAT, P9_DOTL_CREATE }, 172 { O_EXCL, P9_DOTL_EXCL }, 173 { O_NOCTTY, P9_DOTL_NOCTTY }, 174 { O_APPEND, P9_DOTL_APPEND }, 175 { O_NONBLOCK, P9_DOTL_NONBLOCK }, 176 { O_DSYNC, P9_DOTL_DSYNC }, 177 { FASYNC, P9_DOTL_FASYNC }, 178 { O_DIRECT, P9_DOTL_DIRECT }, 179 { O_LARGEFILE, P9_DOTL_LARGEFILE }, 180 { O_DIRECTORY, P9_DOTL_DIRECTORY }, 181 { O_NOFOLLOW, P9_DOTL_NOFOLLOW }, 182 { O_NOATIME, P9_DOTL_NOATIME }, 183 { O_CLOEXEC, P9_DOTL_CLOEXEC }, 184 { O_SYNC, P9_DOTL_SYNC}, 185 }; 186 for (i = 0; i < ARRAY_SIZE(dotl_oflag_map); i++) { 187 if (flags & dotl_oflag_map[i].open_flag) 188 rflags |= dotl_oflag_map[i].dotl_flag; 189 } 190 return rflags; 191 } 192 193 /** 194 * v9fs_open_to_dotl_flags- convert Linux specific open flags to 195 * plan 9 open flag. 196 * @flags: flags to convert 197 */ 198 int v9fs_open_to_dotl_flags(int flags) 199 { 200 int rflags = 0; 201 202 /* 203 * We have same bits for P9_DOTL_READONLY, P9_DOTL_WRONLY 204 * and P9_DOTL_NOACCESS 205 */ 206 rflags |= flags & O_ACCMODE; 207 rflags |= v9fs_mapped_dotl_flags(flags); 208 209 return rflags; 210 } 211 212 /** 213 * v9fs_vfs_create_dotl - VFS hook to create files for 9P2000.L protocol. 214 * @dir: directory inode that is being created 215 * @dentry: dentry that is being deleted 216 * @omode: create permissions 217 * 218 */ 219 220 static int 221 v9fs_vfs_create_dotl(struct user_namespace *mnt_userns, struct inode *dir, 222 struct dentry *dentry, umode_t omode, bool excl) 223 { 224 return v9fs_vfs_mknod_dotl(mnt_userns, dir, dentry, omode, 0); 225 } 226 227 static int 228 v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry, 229 struct file *file, unsigned flags, umode_t omode) 230 { 231 int err = 0; 232 kgid_t gid; 233 umode_t mode; 234 const unsigned char *name = NULL; 235 struct p9_qid qid; 236 struct inode *inode; 237 struct p9_fid *fid = NULL; 238 struct v9fs_inode *v9inode; 239 struct p9_fid *dfid, *ofid, *inode_fid; 240 struct v9fs_session_info *v9ses; 241 struct posix_acl *pacl = NULL, *dacl = NULL; 242 struct dentry *res = NULL; 243 244 if (d_in_lookup(dentry)) { 245 res = v9fs_vfs_lookup(dir, dentry, 0); 246 if (IS_ERR(res)) 247 return PTR_ERR(res); 248 249 if (res) 250 dentry = res; 251 } 252 253 /* Only creates */ 254 if (!(flags & O_CREAT) || d_really_is_positive(dentry)) 255 return finish_no_open(file, res); 256 257 v9ses = v9fs_inode2v9ses(dir); 258 259 name = dentry->d_name.name; 260 p9_debug(P9_DEBUG_VFS, "name:%s flags:0x%x mode:0x%hx\n", 261 name, flags, omode); 262 263 dfid = v9fs_parent_fid(dentry); 264 if (IS_ERR(dfid)) { 265 err = PTR_ERR(dfid); 266 p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err); 267 goto out; 268 } 269 270 /* clone a fid to use for creation */ 271 ofid = clone_fid(dfid); 272 if (IS_ERR(ofid)) { 273 err = PTR_ERR(ofid); 274 p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err); 275 goto out; 276 } 277 278 gid = v9fs_get_fsgid_for_create(dir); 279 280 mode = omode; 281 /* Update mode based on ACL value */ 282 err = v9fs_acl_mode(dir, &mode, &dacl, &pacl); 283 if (err) { 284 p9_debug(P9_DEBUG_VFS, "Failed to get acl values in creat %d\n", 285 err); 286 goto error; 287 } 288 err = p9_client_create_dotl(ofid, name, v9fs_open_to_dotl_flags(flags), 289 mode, gid, &qid); 290 if (err < 0) { 291 p9_debug(P9_DEBUG_VFS, "p9_client_open_dotl failed in creat %d\n", 292 err); 293 goto error; 294 } 295 v9fs_invalidate_inode_attr(dir); 296 297 /* instantiate inode and assign the unopened fid to the dentry */ 298 fid = p9_client_walk(dfid, 1, &name, 1); 299 p9_client_clunk(dfid); 300 if (IS_ERR(fid)) { 301 err = PTR_ERR(fid); 302 p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err); 303 fid = NULL; 304 goto error; 305 } 306 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb); 307 if (IS_ERR(inode)) { 308 err = PTR_ERR(inode); 309 p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n", err); 310 goto error; 311 } 312 /* Now set the ACL based on the default value */ 313 v9fs_set_create_acl(inode, fid, dacl, pacl); 314 315 v9fs_fid_add(dentry, fid); 316 d_instantiate(dentry, inode); 317 318 v9inode = V9FS_I(inode); 319 mutex_lock(&v9inode->v_mutex); 320 if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) && 321 !v9inode->writeback_fid && 322 ((flags & O_ACCMODE) != O_RDONLY)) { 323 /* 324 * clone a fid and add it to writeback_fid 325 * we do it during open time instead of 326 * page dirty time via write_begin/page_mkwrite 327 * because we want write after unlink usecase 328 * to work. 329 */ 330 inode_fid = v9fs_writeback_fid(dentry); 331 if (IS_ERR(inode_fid)) { 332 err = PTR_ERR(inode_fid); 333 mutex_unlock(&v9inode->v_mutex); 334 goto err_clunk_old_fid; 335 } 336 v9inode->writeback_fid = (void *) inode_fid; 337 } 338 mutex_unlock(&v9inode->v_mutex); 339 /* Since we are opening a file, assign the open fid to the file */ 340 err = finish_open(file, dentry, generic_file_open); 341 if (err) 342 goto err_clunk_old_fid; 343 file->private_data = ofid; 344 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) 345 v9fs_cache_inode_set_cookie(inode, file); 346 v9fs_open_fid_add(inode, ofid); 347 file->f_mode |= FMODE_CREATED; 348 out: 349 v9fs_put_acl(dacl, pacl); 350 dput(res); 351 return err; 352 353 error: 354 if (fid) 355 p9_client_clunk(fid); 356 err_clunk_old_fid: 357 if (ofid) 358 p9_client_clunk(ofid); 359 goto out; 360 } 361 362 /** 363 * v9fs_vfs_mkdir_dotl - VFS mkdir hook to create a directory 364 * @dir: inode that is being unlinked 365 * @dentry: dentry that is being unlinked 366 * @omode: mode for new directory 367 * 368 */ 369 370 static int v9fs_vfs_mkdir_dotl(struct user_namespace *mnt_userns, 371 struct inode *dir, struct dentry *dentry, 372 umode_t omode) 373 { 374 int err; 375 struct v9fs_session_info *v9ses; 376 struct p9_fid *fid = NULL, *dfid = NULL; 377 kgid_t gid; 378 const unsigned char *name; 379 umode_t mode; 380 struct inode *inode; 381 struct p9_qid qid; 382 struct posix_acl *dacl = NULL, *pacl = NULL; 383 384 p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry); 385 err = 0; 386 v9ses = v9fs_inode2v9ses(dir); 387 388 omode |= S_IFDIR; 389 if (dir->i_mode & S_ISGID) 390 omode |= S_ISGID; 391 392 dfid = v9fs_parent_fid(dentry); 393 if (IS_ERR(dfid)) { 394 err = PTR_ERR(dfid); 395 p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err); 396 dfid = NULL; 397 goto error; 398 } 399 400 gid = v9fs_get_fsgid_for_create(dir); 401 mode = omode; 402 /* Update mode based on ACL value */ 403 err = v9fs_acl_mode(dir, &mode, &dacl, &pacl); 404 if (err) { 405 p9_debug(P9_DEBUG_VFS, "Failed to get acl values in mkdir %d\n", 406 err); 407 goto error; 408 } 409 name = dentry->d_name.name; 410 err = p9_client_mkdir_dotl(dfid, name, mode, gid, &qid); 411 if (err < 0) 412 goto error; 413 fid = p9_client_walk(dfid, 1, &name, 1); 414 if (IS_ERR(fid)) { 415 err = PTR_ERR(fid); 416 p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", 417 err); 418 fid = NULL; 419 goto error; 420 } 421 422 /* instantiate inode and assign the unopened fid to the dentry */ 423 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) { 424 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb); 425 if (IS_ERR(inode)) { 426 err = PTR_ERR(inode); 427 p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n", 428 err); 429 goto error; 430 } 431 v9fs_fid_add(dentry, fid); 432 v9fs_set_create_acl(inode, fid, dacl, pacl); 433 d_instantiate(dentry, inode); 434 fid = NULL; 435 err = 0; 436 } else { 437 /* 438 * Not in cached mode. No need to populate 439 * inode with stat. We need to get an inode 440 * so that we can set the acl with dentry 441 */ 442 inode = v9fs_get_inode(dir->i_sb, mode, 0); 443 if (IS_ERR(inode)) { 444 err = PTR_ERR(inode); 445 goto error; 446 } 447 v9fs_set_create_acl(inode, fid, dacl, pacl); 448 d_instantiate(dentry, inode); 449 } 450 inc_nlink(dir); 451 v9fs_invalidate_inode_attr(dir); 452 error: 453 if (fid) 454 p9_client_clunk(fid); 455 v9fs_put_acl(dacl, pacl); 456 p9_client_clunk(dfid); 457 return err; 458 } 459 460 static int 461 v9fs_vfs_getattr_dotl(struct user_namespace *mnt_userns, 462 const struct path *path, struct kstat *stat, 463 u32 request_mask, unsigned int flags) 464 { 465 struct dentry *dentry = path->dentry; 466 struct v9fs_session_info *v9ses; 467 struct p9_fid *fid; 468 struct p9_stat_dotl *st; 469 470 p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry); 471 v9ses = v9fs_dentry2v9ses(dentry); 472 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) { 473 generic_fillattr(&init_user_ns, d_inode(dentry), stat); 474 return 0; 475 } 476 fid = v9fs_fid_lookup(dentry); 477 if (IS_ERR(fid)) 478 return PTR_ERR(fid); 479 480 /* Ask for all the fields in stat structure. Server will return 481 * whatever it supports 482 */ 483 484 st = p9_client_getattr_dotl(fid, P9_STATS_ALL); 485 p9_client_clunk(fid); 486 if (IS_ERR(st)) 487 return PTR_ERR(st); 488 489 v9fs_stat2inode_dotl(st, d_inode(dentry), 0); 490 generic_fillattr(&init_user_ns, d_inode(dentry), stat); 491 /* Change block size to what the server returned */ 492 stat->blksize = st->st_blksize; 493 494 kfree(st); 495 return 0; 496 } 497 498 /* 499 * Attribute flags. 500 */ 501 #define P9_ATTR_MODE (1 << 0) 502 #define P9_ATTR_UID (1 << 1) 503 #define P9_ATTR_GID (1 << 2) 504 #define P9_ATTR_SIZE (1 << 3) 505 #define P9_ATTR_ATIME (1 << 4) 506 #define P9_ATTR_MTIME (1 << 5) 507 #define P9_ATTR_CTIME (1 << 6) 508 #define P9_ATTR_ATIME_SET (1 << 7) 509 #define P9_ATTR_MTIME_SET (1 << 8) 510 511 struct dotl_iattr_map { 512 int iattr_valid; 513 int p9_iattr_valid; 514 }; 515 516 static int v9fs_mapped_iattr_valid(int iattr_valid) 517 { 518 int i; 519 int p9_iattr_valid = 0; 520 struct dotl_iattr_map dotl_iattr_map[] = { 521 { ATTR_MODE, P9_ATTR_MODE }, 522 { ATTR_UID, P9_ATTR_UID }, 523 { ATTR_GID, P9_ATTR_GID }, 524 { ATTR_SIZE, P9_ATTR_SIZE }, 525 { ATTR_ATIME, P9_ATTR_ATIME }, 526 { ATTR_MTIME, P9_ATTR_MTIME }, 527 { ATTR_CTIME, P9_ATTR_CTIME }, 528 { ATTR_ATIME_SET, P9_ATTR_ATIME_SET }, 529 { ATTR_MTIME_SET, P9_ATTR_MTIME_SET }, 530 }; 531 for (i = 0; i < ARRAY_SIZE(dotl_iattr_map); i++) { 532 if (iattr_valid & dotl_iattr_map[i].iattr_valid) 533 p9_iattr_valid |= dotl_iattr_map[i].p9_iattr_valid; 534 } 535 return p9_iattr_valid; 536 } 537 538 /** 539 * v9fs_vfs_setattr_dotl - set file metadata 540 * @dentry: file whose metadata to set 541 * @iattr: metadata assignment structure 542 * 543 */ 544 545 int v9fs_vfs_setattr_dotl(struct user_namespace *mnt_userns, 546 struct dentry *dentry, struct iattr *iattr) 547 { 548 int retval, use_dentry = 0; 549 struct p9_fid *fid = NULL; 550 struct p9_iattr_dotl p9attr; 551 struct inode *inode = d_inode(dentry); 552 553 p9_debug(P9_DEBUG_VFS, "\n"); 554 555 retval = setattr_prepare(&init_user_ns, dentry, iattr); 556 if (retval) 557 return retval; 558 559 p9attr.valid = v9fs_mapped_iattr_valid(iattr->ia_valid); 560 p9attr.mode = iattr->ia_mode; 561 p9attr.uid = iattr->ia_uid; 562 p9attr.gid = iattr->ia_gid; 563 p9attr.size = iattr->ia_size; 564 p9attr.atime_sec = iattr->ia_atime.tv_sec; 565 p9attr.atime_nsec = iattr->ia_atime.tv_nsec; 566 p9attr.mtime_sec = iattr->ia_mtime.tv_sec; 567 p9attr.mtime_nsec = iattr->ia_mtime.tv_nsec; 568 569 if (iattr->ia_valid & ATTR_FILE) { 570 fid = iattr->ia_file->private_data; 571 WARN_ON(!fid); 572 } 573 if (!fid) { 574 fid = v9fs_fid_lookup(dentry); 575 use_dentry = 1; 576 } 577 if (IS_ERR(fid)) 578 return PTR_ERR(fid); 579 580 /* Write all dirty data */ 581 if (S_ISREG(inode->i_mode)) 582 filemap_write_and_wait(inode->i_mapping); 583 584 retval = p9_client_setattr(fid, &p9attr); 585 if (retval < 0) { 586 if (use_dentry) 587 p9_client_clunk(fid); 588 return retval; 589 } 590 591 if ((iattr->ia_valid & ATTR_SIZE) && 592 iattr->ia_size != i_size_read(inode)) 593 truncate_setsize(inode, iattr->ia_size); 594 595 v9fs_invalidate_inode_attr(inode); 596 setattr_copy(&init_user_ns, inode, iattr); 597 mark_inode_dirty(inode); 598 if (iattr->ia_valid & ATTR_MODE) { 599 /* We also want to update ACL when we update mode bits */ 600 retval = v9fs_acl_chmod(inode, fid); 601 if (retval < 0) { 602 if (use_dentry) 603 p9_client_clunk(fid); 604 return retval; 605 } 606 } 607 if (use_dentry) 608 p9_client_clunk(fid); 609 610 return 0; 611 } 612 613 /** 614 * v9fs_stat2inode_dotl - populate an inode structure with stat info 615 * @stat: stat structure 616 * @inode: inode to populate 617 * @flags: ctrl flags (e.g. V9FS_STAT2INODE_KEEP_ISIZE) 618 * 619 */ 620 621 void 622 v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode, 623 unsigned int flags) 624 { 625 umode_t mode; 626 struct v9fs_inode *v9inode = V9FS_I(inode); 627 628 if ((stat->st_result_mask & P9_STATS_BASIC) == P9_STATS_BASIC) { 629 inode->i_atime.tv_sec = stat->st_atime_sec; 630 inode->i_atime.tv_nsec = stat->st_atime_nsec; 631 inode->i_mtime.tv_sec = stat->st_mtime_sec; 632 inode->i_mtime.tv_nsec = stat->st_mtime_nsec; 633 inode->i_ctime.tv_sec = stat->st_ctime_sec; 634 inode->i_ctime.tv_nsec = stat->st_ctime_nsec; 635 inode->i_uid = stat->st_uid; 636 inode->i_gid = stat->st_gid; 637 set_nlink(inode, stat->st_nlink); 638 639 mode = stat->st_mode & S_IALLUGO; 640 mode |= inode->i_mode & ~S_IALLUGO; 641 inode->i_mode = mode; 642 643 if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE)) 644 v9fs_i_size_write(inode, stat->st_size); 645 inode->i_blocks = stat->st_blocks; 646 } else { 647 if (stat->st_result_mask & P9_STATS_ATIME) { 648 inode->i_atime.tv_sec = stat->st_atime_sec; 649 inode->i_atime.tv_nsec = stat->st_atime_nsec; 650 } 651 if (stat->st_result_mask & P9_STATS_MTIME) { 652 inode->i_mtime.tv_sec = stat->st_mtime_sec; 653 inode->i_mtime.tv_nsec = stat->st_mtime_nsec; 654 } 655 if (stat->st_result_mask & P9_STATS_CTIME) { 656 inode->i_ctime.tv_sec = stat->st_ctime_sec; 657 inode->i_ctime.tv_nsec = stat->st_ctime_nsec; 658 } 659 if (stat->st_result_mask & P9_STATS_UID) 660 inode->i_uid = stat->st_uid; 661 if (stat->st_result_mask & P9_STATS_GID) 662 inode->i_gid = stat->st_gid; 663 if (stat->st_result_mask & P9_STATS_NLINK) 664 set_nlink(inode, stat->st_nlink); 665 if (stat->st_result_mask & P9_STATS_MODE) { 666 inode->i_mode = stat->st_mode; 667 if ((S_ISBLK(inode->i_mode)) || 668 (S_ISCHR(inode->i_mode))) 669 init_special_inode(inode, inode->i_mode, 670 inode->i_rdev); 671 } 672 if (stat->st_result_mask & P9_STATS_RDEV) 673 inode->i_rdev = new_decode_dev(stat->st_rdev); 674 if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE) && 675 stat->st_result_mask & P9_STATS_SIZE) 676 v9fs_i_size_write(inode, stat->st_size); 677 if (stat->st_result_mask & P9_STATS_BLOCKS) 678 inode->i_blocks = stat->st_blocks; 679 } 680 if (stat->st_result_mask & P9_STATS_GEN) 681 inode->i_generation = stat->st_gen; 682 683 /* Currently we don't support P9_STATS_BTIME and P9_STATS_DATA_VERSION 684 * because the inode structure does not have fields for them. 685 */ 686 v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR; 687 } 688 689 static int 690 v9fs_vfs_symlink_dotl(struct user_namespace *mnt_userns, struct inode *dir, 691 struct dentry *dentry, const char *symname) 692 { 693 int err; 694 kgid_t gid; 695 const unsigned char *name; 696 struct p9_qid qid; 697 struct inode *inode; 698 struct p9_fid *dfid; 699 struct p9_fid *fid = NULL; 700 struct v9fs_session_info *v9ses; 701 702 name = dentry->d_name.name; 703 p9_debug(P9_DEBUG_VFS, "%lu,%s,%s\n", dir->i_ino, name, symname); 704 v9ses = v9fs_inode2v9ses(dir); 705 706 dfid = v9fs_parent_fid(dentry); 707 if (IS_ERR(dfid)) { 708 err = PTR_ERR(dfid); 709 p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err); 710 return err; 711 } 712 713 gid = v9fs_get_fsgid_for_create(dir); 714 715 /* Server doesn't alter fid on TSYMLINK. Hence no need to clone it. */ 716 err = p9_client_symlink(dfid, name, symname, gid, &qid); 717 718 if (err < 0) { 719 p9_debug(P9_DEBUG_VFS, "p9_client_symlink failed %d\n", err); 720 goto error; 721 } 722 723 v9fs_invalidate_inode_attr(dir); 724 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) { 725 /* Now walk from the parent so we can get an unopened fid. */ 726 fid = p9_client_walk(dfid, 1, &name, 1); 727 if (IS_ERR(fid)) { 728 err = PTR_ERR(fid); 729 p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", 730 err); 731 fid = NULL; 732 goto error; 733 } 734 735 /* instantiate inode and assign the unopened fid to dentry */ 736 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb); 737 if (IS_ERR(inode)) { 738 err = PTR_ERR(inode); 739 p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n", 740 err); 741 goto error; 742 } 743 v9fs_fid_add(dentry, fid); 744 d_instantiate(dentry, inode); 745 fid = NULL; 746 err = 0; 747 } else { 748 /* Not in cached mode. No need to populate inode with stat */ 749 inode = v9fs_get_inode(dir->i_sb, S_IFLNK, 0); 750 if (IS_ERR(inode)) { 751 err = PTR_ERR(inode); 752 goto error; 753 } 754 d_instantiate(dentry, inode); 755 } 756 757 error: 758 if (fid) 759 p9_client_clunk(fid); 760 761 p9_client_clunk(dfid); 762 return err; 763 } 764 765 /** 766 * v9fs_vfs_link_dotl - create a hardlink for dotl 767 * @old_dentry: dentry for file to link to 768 * @dir: inode destination for new link 769 * @dentry: dentry for link 770 * 771 */ 772 773 static int 774 v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir, 775 struct dentry *dentry) 776 { 777 int err; 778 struct p9_fid *dfid, *oldfid; 779 struct v9fs_session_info *v9ses; 780 781 p9_debug(P9_DEBUG_VFS, "dir ino: %lu, old_name: %pd, new_name: %pd\n", 782 dir->i_ino, old_dentry, dentry); 783 784 v9ses = v9fs_inode2v9ses(dir); 785 dfid = v9fs_parent_fid(dentry); 786 if (IS_ERR(dfid)) 787 return PTR_ERR(dfid); 788 789 oldfid = v9fs_fid_lookup(old_dentry); 790 if (IS_ERR(oldfid)) { 791 p9_client_clunk(dfid); 792 return PTR_ERR(oldfid); 793 } 794 795 err = p9_client_link(dfid, oldfid, dentry->d_name.name); 796 797 p9_client_clunk(dfid); 798 p9_client_clunk(oldfid); 799 if (err < 0) { 800 p9_debug(P9_DEBUG_VFS, "p9_client_link failed %d\n", err); 801 return err; 802 } 803 804 v9fs_invalidate_inode_attr(dir); 805 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) { 806 /* Get the latest stat info from server. */ 807 struct p9_fid *fid; 808 fid = v9fs_fid_lookup(old_dentry); 809 if (IS_ERR(fid)) 810 return PTR_ERR(fid); 811 812 v9fs_refresh_inode_dotl(fid, d_inode(old_dentry)); 813 p9_client_clunk(fid); 814 } 815 ihold(d_inode(old_dentry)); 816 d_instantiate(dentry, d_inode(old_dentry)); 817 818 return err; 819 } 820 821 /** 822 * v9fs_vfs_mknod_dotl - create a special file 823 * @dir: inode destination for new link 824 * @dentry: dentry for file 825 * @omode: mode for creation 826 * @rdev: device associated with special file 827 * 828 */ 829 static int 830 v9fs_vfs_mknod_dotl(struct user_namespace *mnt_userns, struct inode *dir, 831 struct dentry *dentry, umode_t omode, dev_t rdev) 832 { 833 int err; 834 kgid_t gid; 835 const unsigned char *name; 836 umode_t mode; 837 struct v9fs_session_info *v9ses; 838 struct p9_fid *fid = NULL, *dfid = NULL; 839 struct inode *inode; 840 struct p9_qid qid; 841 struct posix_acl *dacl = NULL, *pacl = NULL; 842 843 p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %hx MAJOR: %u MINOR: %u\n", 844 dir->i_ino, dentry, omode, 845 MAJOR(rdev), MINOR(rdev)); 846 847 v9ses = v9fs_inode2v9ses(dir); 848 dfid = v9fs_parent_fid(dentry); 849 if (IS_ERR(dfid)) { 850 err = PTR_ERR(dfid); 851 p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err); 852 dfid = NULL; 853 goto error; 854 } 855 856 gid = v9fs_get_fsgid_for_create(dir); 857 mode = omode; 858 /* Update mode based on ACL value */ 859 err = v9fs_acl_mode(dir, &mode, &dacl, &pacl); 860 if (err) { 861 p9_debug(P9_DEBUG_VFS, "Failed to get acl values in mknod %d\n", 862 err); 863 goto error; 864 } 865 name = dentry->d_name.name; 866 867 err = p9_client_mknod_dotl(dfid, name, mode, rdev, gid, &qid); 868 if (err < 0) 869 goto error; 870 871 v9fs_invalidate_inode_attr(dir); 872 fid = p9_client_walk(dfid, 1, &name, 1); 873 if (IS_ERR(fid)) { 874 err = PTR_ERR(fid); 875 p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", 876 err); 877 fid = NULL; 878 goto error; 879 } 880 881 /* instantiate inode and assign the unopened fid to the dentry */ 882 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) { 883 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb); 884 if (IS_ERR(inode)) { 885 err = PTR_ERR(inode); 886 p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n", 887 err); 888 goto error; 889 } 890 v9fs_set_create_acl(inode, fid, dacl, pacl); 891 v9fs_fid_add(dentry, fid); 892 d_instantiate(dentry, inode); 893 fid = NULL; 894 err = 0; 895 } else { 896 /* 897 * Not in cached mode. No need to populate inode with stat. 898 * socket syscall returns a fd, so we need instantiate 899 */ 900 inode = v9fs_get_inode(dir->i_sb, mode, rdev); 901 if (IS_ERR(inode)) { 902 err = PTR_ERR(inode); 903 goto error; 904 } 905 v9fs_set_create_acl(inode, fid, dacl, pacl); 906 d_instantiate(dentry, inode); 907 } 908 error: 909 if (fid) 910 p9_client_clunk(fid); 911 v9fs_put_acl(dacl, pacl); 912 p9_client_clunk(dfid); 913 914 return err; 915 } 916 917 /** 918 * v9fs_vfs_get_link_dotl - follow a symlink path 919 * @dentry: dentry for symlink 920 * @inode: inode for symlink 921 * @done: destructor for return value 922 */ 923 924 static const char * 925 v9fs_vfs_get_link_dotl(struct dentry *dentry, 926 struct inode *inode, 927 struct delayed_call *done) 928 { 929 struct p9_fid *fid; 930 char *target; 931 int retval; 932 933 if (!dentry) 934 return ERR_PTR(-ECHILD); 935 936 p9_debug(P9_DEBUG_VFS, "%pd\n", dentry); 937 938 fid = v9fs_fid_lookup(dentry); 939 if (IS_ERR(fid)) 940 return ERR_CAST(fid); 941 retval = p9_client_readlink(fid, &target); 942 p9_client_clunk(fid); 943 if (retval) 944 return ERR_PTR(retval); 945 set_delayed_call(done, kfree_link, target); 946 return target; 947 } 948 949 int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode) 950 { 951 struct p9_stat_dotl *st; 952 struct v9fs_session_info *v9ses; 953 unsigned int flags; 954 955 v9ses = v9fs_inode2v9ses(inode); 956 st = p9_client_getattr_dotl(fid, P9_STATS_ALL); 957 if (IS_ERR(st)) 958 return PTR_ERR(st); 959 /* 960 * Don't update inode if the file type is different 961 */ 962 if ((inode->i_mode & S_IFMT) != (st->st_mode & S_IFMT)) 963 goto out; 964 965 /* 966 * We don't want to refresh inode->i_size, 967 * because we may have cached data 968 */ 969 flags = (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) ? 970 V9FS_STAT2INODE_KEEP_ISIZE : 0; 971 v9fs_stat2inode_dotl(st, inode, flags); 972 out: 973 kfree(st); 974 return 0; 975 } 976 977 const struct inode_operations v9fs_dir_inode_operations_dotl = { 978 .create = v9fs_vfs_create_dotl, 979 .atomic_open = v9fs_vfs_atomic_open_dotl, 980 .lookup = v9fs_vfs_lookup, 981 .link = v9fs_vfs_link_dotl, 982 .symlink = v9fs_vfs_symlink_dotl, 983 .unlink = v9fs_vfs_unlink, 984 .mkdir = v9fs_vfs_mkdir_dotl, 985 .rmdir = v9fs_vfs_rmdir, 986 .mknod = v9fs_vfs_mknod_dotl, 987 .rename = v9fs_vfs_rename, 988 .getattr = v9fs_vfs_getattr_dotl, 989 .setattr = v9fs_vfs_setattr_dotl, 990 .listxattr = v9fs_listxattr, 991 .get_acl = v9fs_iop_get_acl, 992 }; 993 994 const struct inode_operations v9fs_file_inode_operations_dotl = { 995 .getattr = v9fs_vfs_getattr_dotl, 996 .setattr = v9fs_vfs_setattr_dotl, 997 .listxattr = v9fs_listxattr, 998 .get_acl = v9fs_iop_get_acl, 999 }; 1000 1001 const struct inode_operations v9fs_symlink_inode_operations_dotl = { 1002 .get_link = v9fs_vfs_get_link_dotl, 1003 .getattr = v9fs_vfs_getattr_dotl, 1004 .setattr = v9fs_vfs_setattr_dotl, 1005 .listxattr = v9fs_listxattr, 1006 }; 1007