vfs_inode_dotl.c 25.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
/*
 *  linux/fs/9p/vfs_inode_dotl.c
 *
 * This file contains vfs inode ops for the 9P2000.L protocol.
 *
 *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to:
 *  Free Software Foundation
 *  51 Franklin Street, Fifth Floor
 *  Boston, MA  02111-1301  USA
 *
 */

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/pagemap.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/inet.h>
#include <linux/namei.h>
#include <linux/idr.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/xattr.h>
#include <linux/posix_acl.h>
#include <net/9p/9p.h>
#include <net/9p/client.h>

#include "v9fs.h"
#include "v9fs_vfs.h"
#include "fid.h"
#include "cache.h"
#include "xattr.h"
#include "acl.h"

static int
A
Al Viro 已提交
51
v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
52 53 54 55 56 57 58 59
		    dev_t rdev);

/**
 * v9fs_get_fsgid_for_create - Helper function to get the gid for creating a
 * new file system object. This checks the S_ISGID to determine the owning
 * group of the new file system object.
 */

60
static kgid_t v9fs_get_fsgid_for_create(struct inode *dir_inode)
61 62 63 64 65 66 67 68 69 70
{
	BUG_ON(dir_inode == NULL);

	if (dir_inode->i_mode & S_ISGID) {
		/* set_gid bit is set.*/
		return dir_inode->i_gid;
	}
	return current_fsgid();
}

71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
static int v9fs_test_inode_dotl(struct inode *inode, void *data)
{
	struct v9fs_inode *v9inode = V9FS_I(inode);
	struct p9_stat_dotl *st = (struct p9_stat_dotl *)data;

	/* don't match inode of different type */
	if ((inode->i_mode & S_IFMT) != (st->st_mode & S_IFMT))
		return 0;

	if (inode->i_generation != st->st_gen)
		return 0;

	/* compare qid details */
	if (memcmp(&v9inode->qid.version,
		   &st->qid.version, sizeof(v9inode->qid.version)))
		return 0;

	if (v9inode->qid.type != st->qid.type)
		return 0;
	return 1;
}

93 94 95 96 97 98
/* Always get a new inode */
static int v9fs_test_new_inode_dotl(struct inode *inode, void *data)
{
	return 0;
}

99 100 101 102 103 104 105 106 107 108
static int v9fs_set_inode_dotl(struct inode *inode,  void *data)
{
	struct v9fs_inode *v9inode = V9FS_I(inode);
	struct p9_stat_dotl *st = (struct p9_stat_dotl *)data;

	memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
	inode->i_generation = st->st_gen;
	return 0;
}

A
Aneesh Kumar K.V 已提交
109 110 111
static struct inode *v9fs_qid_iget_dotl(struct super_block *sb,
					struct p9_qid *qid,
					struct p9_fid *fid,
112 113
					struct p9_stat_dotl *st,
					int new)
A
Aneesh Kumar K.V 已提交
114 115 116 117 118
{
	int retval;
	unsigned long i_ino;
	struct inode *inode;
	struct v9fs_session_info *v9ses = sb->s_fs_info;
119 120 121 122 123 124
	int (*test)(struct inode *, void *);

	if (new)
		test = v9fs_test_new_inode_dotl;
	else
		test = v9fs_test_inode_dotl;
A
Aneesh Kumar K.V 已提交
125 126

	i_ino = v9fs_qid2ino(qid);
127
	inode = iget5_locked(sb, i_ino, test, v9fs_set_inode_dotl, st);
A
Aneesh Kumar K.V 已提交
128 129 130 131 132 133 134 135 136
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;
	/*
	 * initialize the inode with the stat info
	 * FIXME!! we may need support for stale inodes
	 * later.
	 */
137
	inode->i_ino = i_ino;
138 139
	retval = v9fs_init_inode(v9ses, inode,
				 st->st_mode, new_decode_dev(st->st_rdev));
A
Aneesh Kumar K.V 已提交
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
	if (retval)
		goto error;

	v9fs_stat2inode_dotl(st, inode);
#ifdef CONFIG_9P_FSCACHE
	v9fs_cache_inode_get_cookie(inode);
#endif
	retval = v9fs_get_acl(inode, fid);
	if (retval)
		goto error;

	unlock_new_inode(inode);
	return inode;
error:
	unlock_new_inode(inode);
	iput(inode);
	return ERR_PTR(retval);

}

160
struct inode *
A
Aneesh Kumar K.V 已提交
161
v9fs_inode_from_fid_dotl(struct v9fs_session_info *v9ses, struct p9_fid *fid,
162
			 struct super_block *sb, int new)
163 164
{
	struct p9_stat_dotl *st;
A
Aneesh Kumar K.V 已提交
165
	struct inode *inode = NULL;
166

167
	st = p9_client_getattr_dotl(fid, P9_STATS_BASIC | P9_STATS_GEN);
168 169 170
	if (IS_ERR(st))
		return ERR_CAST(st);

171
	inode = v9fs_qid_iget_dotl(sb, &st->qid, fid, st, new);
172
	kfree(st);
A
Aneesh Kumar K.V 已提交
173
	return inode;
174 175
}

176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
struct dotl_openflag_map {
	int open_flag;
	int dotl_flag;
};

static int v9fs_mapped_dotl_flags(int flags)
{
	int i;
	int rflags = 0;
	struct dotl_openflag_map dotl_oflag_map[] = {
		{ O_CREAT,	P9_DOTL_CREATE },
		{ O_EXCL,	P9_DOTL_EXCL },
		{ O_NOCTTY,	P9_DOTL_NOCTTY },
		{ O_APPEND,	P9_DOTL_APPEND },
		{ O_NONBLOCK,	P9_DOTL_NONBLOCK },
		{ O_DSYNC,	P9_DOTL_DSYNC },
		{ FASYNC,	P9_DOTL_FASYNC },
		{ O_DIRECT,	P9_DOTL_DIRECT },
		{ O_LARGEFILE,	P9_DOTL_LARGEFILE },
		{ O_DIRECTORY,	P9_DOTL_DIRECTORY },
		{ O_NOFOLLOW,	P9_DOTL_NOFOLLOW },
		{ O_NOATIME,	P9_DOTL_NOATIME },
		{ O_CLOEXEC,	P9_DOTL_CLOEXEC },
		{ O_SYNC,	P9_DOTL_SYNC},
	};
	for (i = 0; i < ARRAY_SIZE(dotl_oflag_map); i++) {
		if (flags & dotl_oflag_map[i].open_flag)
			rflags |= dotl_oflag_map[i].dotl_flag;
	}
	return rflags;
}

/**
 * v9fs_open_to_dotl_flags- convert Linux specific open flags to
 * plan 9 open flag.
 * @flags: flags to convert
 */
int v9fs_open_to_dotl_flags(int flags)
{
	int rflags = 0;

	/*
	 * We have same bits for P9_DOTL_READONLY, P9_DOTL_WRONLY
	 * and P9_DOTL_NOACCESS
	 */
	rflags |= flags & O_ACCMODE;
	rflags |= v9fs_mapped_dotl_flags(flags);

	return rflags;
}

227 228 229 230 231 232 233 234 235
/**
 * v9fs_vfs_create_dotl - VFS hook to create files for 9P2000.L protocol.
 * @dir: directory inode that is being created
 * @dentry:  dentry that is being deleted
 * @mode: create permissions
 *
 */

static int
A
Al Viro 已提交
236
v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
A
Al Viro 已提交
237
		bool excl)
238 239 240 241
{
	return v9fs_vfs_mknod_dotl(dir, dentry, omode, 0);
}

A
Al Viro 已提交
242
static int
243
v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
244
			  struct file *file, unsigned flags, umode_t omode,
245
			  int *opened)
246 247
{
	int err = 0;
248
	kgid_t gid;
A
Al Viro 已提交
249
	umode_t mode;
250
	char *name = NULL;
251 252
	struct p9_qid qid;
	struct inode *inode;
253 254 255 256
	struct p9_fid *fid = NULL;
	struct v9fs_inode *v9inode;
	struct p9_fid *dfid, *ofid, *inode_fid;
	struct v9fs_session_info *v9ses;
257
	struct posix_acl *pacl = NULL, *dacl = NULL;
258
	struct dentry *res = NULL;
259

260
	if (d_unhashed(dentry)) {
A
Al Viro 已提交
261
		res = v9fs_vfs_lookup(dir, dentry, 0);
262
		if (IS_ERR(res))
A
Al Viro 已提交
263
			return PTR_ERR(res);
264 265 266 267 268 269

		if (res)
			dentry = res;
	}

	/* Only creates */
M
M. Mohan Kumar 已提交
270 271 272 273 274 275 276 277
	if (!(flags & O_CREAT))
		return	finish_no_open(file, res);
	else if (dentry->d_inode) {
		if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
			return -EEXIST;
		else
			return finish_no_open(file, res);
	}
278

279 280
	v9ses = v9fs_inode2v9ses(dir);

281
	name = (char *) dentry->d_name.name;
282
	p9_debug(P9_DEBUG_VFS, "name:%s flags:0x%x mode:0x%hx\n",
283
		 name, flags, omode);
284 285 286 287

	dfid = v9fs_fid_lookup(dentry->d_parent);
	if (IS_ERR(dfid)) {
		err = PTR_ERR(dfid);
288
		p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
A
Al Viro 已提交
289
		goto out;
290 291 292 293 294 295
	}

	/* clone a fid to use for creation */
	ofid = p9_client_walk(dfid, 0, NULL, 1);
	if (IS_ERR(ofid)) {
		err = PTR_ERR(ofid);
296
		p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
A
Al Viro 已提交
297
		goto out;
298 299 300 301 302 303 304 305
	}

	gid = v9fs_get_fsgid_for_create(dir);

	mode = omode;
	/* Update mode based on ACL value */
	err = v9fs_acl_mode(dir, &mode, &dacl, &pacl);
	if (err) {
306 307
		p9_debug(P9_DEBUG_VFS, "Failed to get acl values in creat %d\n",
			 err);
308 309
		goto error;
	}
310 311
	err = p9_client_create_dotl(ofid, name, v9fs_open_to_dotl_flags(flags),
				    mode, gid, &qid);
312
	if (err < 0) {
313 314
		p9_debug(P9_DEBUG_VFS, "p9_client_open_dotl failed in creat %d\n",
			 err);
315 316
		goto error;
	}
317
	v9fs_invalidate_inode_attr(dir);
318

319 320 321 322
	/* instantiate inode and assign the unopened fid to the dentry */
	fid = p9_client_walk(dfid, 1, &name, 1);
	if (IS_ERR(fid)) {
		err = PTR_ERR(fid);
323
		p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
324
		fid = NULL;
325
		goto error;
326
	}
327
	inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
328 329
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
330
		p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n", err);
331 332
		goto error;
	}
333 334 335
	/* Now set the ACL based on the default value */
	v9fs_set_create_acl(inode, fid, dacl, pacl);

336 337 338
	err = v9fs_fid_add(dentry, fid);
	if (err < 0)
		goto error;
339
	d_instantiate(dentry, inode);
340

341
	v9inode = V9FS_I(inode);
342
	mutex_lock(&v9inode->v_mutex);
343 344
	if (v9ses->cache && !v9inode->writeback_fid &&
	    ((flags & O_ACCMODE) != O_RDONLY)) {
345
		/*
346
		 * clone a fid and add it to writeback_fid
347 348 349 350 351 352 353 354
		 * we do it during open time instead of
		 * page dirty time via write_begin/page_mkwrite
		 * because we want write after unlink usecase
		 * to work.
		 */
		inode_fid = v9fs_writeback_fid(dentry);
		if (IS_ERR(inode_fid)) {
			err = PTR_ERR(inode_fid);
355
			mutex_unlock(&v9inode->v_mutex);
356
			goto err_clunk_old_fid;
357
		}
358
		v9inode->writeback_fid = (void *) inode_fid;
359
	}
360
	mutex_unlock(&v9inode->v_mutex);
361
	/* Since we are opening a file, assign the open fid to the file */
A
Al Viro 已提交
362 363
	err = finish_open(file, dentry, generic_file_open, opened);
	if (err)
364
		goto err_clunk_old_fid;
A
Al Viro 已提交
365
	file->private_data = ofid;
366 367
#ifdef CONFIG_9P_FSCACHE
	if (v9ses->cache)
A
Al Viro 已提交
368
		v9fs_cache_inode_set_cookie(inode, file);
369
#endif
370
	*opened |= FILE_CREATED;
371
out:
372
	v9fs_put_acl(dacl, pacl);
373
	dput(res);
A
Al Viro 已提交
374
	return err;
375 376 377 378

error:
	if (fid)
		p9_client_clunk(fid);
379 380 381
err_clunk_old_fid:
	if (ofid)
		p9_client_clunk(ofid);
382
	goto out;
383 384 385 386 387 388 389 390 391 392 393
}

/**
 * v9fs_vfs_mkdir_dotl - VFS mkdir hook to create a directory
 * @dir:  inode that is being unlinked
 * @dentry: dentry that is being unlinked
 * @mode: mode for new directory
 *
 */

static int v9fs_vfs_mkdir_dotl(struct inode *dir,
394
			       struct dentry *dentry, umode_t omode)
395 396 397 398
{
	int err;
	struct v9fs_session_info *v9ses;
	struct p9_fid *fid = NULL, *dfid = NULL;
399
	kgid_t gid;
400
	char *name;
A
Al Viro 已提交
401
	umode_t mode;
402 403 404 405 406
	struct inode *inode;
	struct p9_qid qid;
	struct dentry *dir_dentry;
	struct posix_acl *dacl = NULL, *pacl = NULL;

407
	p9_debug(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
408 409 410 411 412 413 414
	err = 0;
	v9ses = v9fs_inode2v9ses(dir);

	omode |= S_IFDIR;
	if (dir->i_mode & S_ISGID)
		omode |= S_ISGID;

A
Al Viro 已提交
415
	dir_dentry = dentry->d_parent;
416 417 418
	dfid = v9fs_fid_lookup(dir_dentry);
	if (IS_ERR(dfid)) {
		err = PTR_ERR(dfid);
419
		p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
420 421 422 423 424 425 426 427 428
		dfid = NULL;
		goto error;
	}

	gid = v9fs_get_fsgid_for_create(dir);
	mode = omode;
	/* Update mode based on ACL value */
	err = v9fs_acl_mode(dir, &mode, &dacl, &pacl);
	if (err) {
429 430
		p9_debug(P9_DEBUG_VFS, "Failed to get acl values in mkdir %d\n",
			 err);
431 432 433 434 435 436 437
		goto error;
	}
	name = (char *) dentry->d_name.name;
	err = p9_client_mkdir_dotl(dfid, name, mode, gid, &qid);
	if (err < 0)
		goto error;

438 439 440 441 442 443 444 445 446
	fid = p9_client_walk(dfid, 1, &name, 1);
	if (IS_ERR(fid)) {
		err = PTR_ERR(fid);
		p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
			 err);
		fid = NULL;
		goto error;
	}

447 448
	/* instantiate inode and assign the unopened fid to the dentry */
	if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
449
		inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
450 451
		if (IS_ERR(inode)) {
			err = PTR_ERR(inode);
452 453
			p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n",
				 err);
454 455 456 457 458
			goto error;
		}
		err = v9fs_fid_add(dentry, fid);
		if (err < 0)
			goto error;
459
		v9fs_set_create_acl(inode, fid, dacl, pacl);
460
		d_instantiate(dentry, inode);
461 462 463 464 465 466 467
		fid = NULL;
	} else {
		/*
		 * Not in cached mode. No need to populate
		 * inode with stat. We need to get an inode
		 * so that we can set the acl with dentry
		 */
468
		inode = v9fs_get_inode(dir->i_sb, mode, 0);
469 470 471 472
		if (IS_ERR(inode)) {
			err = PTR_ERR(inode);
			goto error;
		}
473
		v9fs_set_create_acl(inode, fid, dacl, pacl);
474 475
		d_instantiate(dentry, inode);
	}
476
	inc_nlink(dir);
477
	v9fs_invalidate_inode_attr(dir);
478 479 480
error:
	if (fid)
		p9_client_clunk(fid);
481
	v9fs_put_acl(dacl, pacl);
482 483 484 485 486 487 488 489 490 491 492 493
	return err;
}

static int
v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
		 struct kstat *stat)
{
	int err;
	struct v9fs_session_info *v9ses;
	struct p9_fid *fid;
	struct p9_stat_dotl *st;

494
	p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
495
	err = -EPERM;
A
Aneesh Kumar K.V 已提交
496
	v9ses = v9fs_dentry2v9ses(dentry);
497 498 499 500
	if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
		generic_fillattr(dentry->d_inode, stat);
		return 0;
	}
501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
	fid = v9fs_fid_lookup(dentry);
	if (IS_ERR(fid))
		return PTR_ERR(fid);

	/* Ask for all the fields in stat structure. Server will return
	 * whatever it supports
	 */

	st = p9_client_getattr_dotl(fid, P9_STATS_ALL);
	if (IS_ERR(st))
		return PTR_ERR(st);

	v9fs_stat2inode_dotl(st, dentry->d_inode);
	generic_fillattr(dentry->d_inode, stat);
	/* Change block size to what the server returned */
	stat->blksize = st->st_blksize;

	kfree(st);
	return 0;
}

522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561
/*
 * Attribute flags.
 */
#define P9_ATTR_MODE		(1 << 0)
#define P9_ATTR_UID		(1 << 1)
#define P9_ATTR_GID		(1 << 2)
#define P9_ATTR_SIZE		(1 << 3)
#define P9_ATTR_ATIME		(1 << 4)
#define P9_ATTR_MTIME		(1 << 5)
#define P9_ATTR_CTIME		(1 << 6)
#define P9_ATTR_ATIME_SET	(1 << 7)
#define P9_ATTR_MTIME_SET	(1 << 8)

struct dotl_iattr_map {
	int iattr_valid;
	int p9_iattr_valid;
};

static int v9fs_mapped_iattr_valid(int iattr_valid)
{
	int i;
	int p9_iattr_valid = 0;
	struct dotl_iattr_map dotl_iattr_map[] = {
		{ ATTR_MODE,		P9_ATTR_MODE },
		{ ATTR_UID,		P9_ATTR_UID },
		{ ATTR_GID,		P9_ATTR_GID },
		{ ATTR_SIZE,		P9_ATTR_SIZE },
		{ ATTR_ATIME,		P9_ATTR_ATIME },
		{ ATTR_MTIME,		P9_ATTR_MTIME },
		{ ATTR_CTIME,		P9_ATTR_CTIME },
		{ ATTR_ATIME_SET,	P9_ATTR_ATIME_SET },
		{ ATTR_MTIME_SET,	P9_ATTR_MTIME_SET },
	};
	for (i = 0; i < ARRAY_SIZE(dotl_iattr_map); i++) {
		if (iattr_valid & dotl_iattr_map[i].iattr_valid)
			p9_iattr_valid |= dotl_iattr_map[i].p9_iattr_valid;
	}
	return p9_iattr_valid;
}

562 563 564 565 566 567 568 569 570 571 572 573 574
/**
 * v9fs_vfs_setattr_dotl - set file metadata
 * @dentry: file whose metadata to set
 * @iattr: metadata assignment structure
 *
 */

int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
{
	int retval;
	struct v9fs_session_info *v9ses;
	struct p9_fid *fid;
	struct p9_iattr_dotl p9attr;
575
	struct inode *inode = dentry->d_inode;
576

577
	p9_debug(P9_DEBUG_VFS, "\n");
578

579
	retval = inode_change_ok(inode, iattr);
580 581 582
	if (retval)
		return retval;

583
	p9attr.valid = v9fs_mapped_iattr_valid(iattr->ia_valid);
584 585 586 587 588 589 590 591 592 593
	p9attr.mode = iattr->ia_mode;
	p9attr.uid = iattr->ia_uid;
	p9attr.gid = iattr->ia_gid;
	p9attr.size = iattr->ia_size;
	p9attr.atime_sec = iattr->ia_atime.tv_sec;
	p9attr.atime_nsec = iattr->ia_atime.tv_nsec;
	p9attr.mtime_sec = iattr->ia_mtime.tv_sec;
	p9attr.mtime_nsec = iattr->ia_mtime.tv_nsec;

	retval = -EPERM;
A
Aneesh Kumar K.V 已提交
594
	v9ses = v9fs_dentry2v9ses(dentry);
595 596 597 598
	fid = v9fs_fid_lookup(dentry);
	if (IS_ERR(fid))
		return PTR_ERR(fid);

599
	/* Write all dirty data */
600 601
	if (S_ISREG(inode->i_mode))
		filemap_write_and_wait(inode->i_mapping);
602

603 604 605
	retval = p9_client_setattr(fid, &p9attr);
	if (retval < 0)
		return retval;
606

607
	if ((iattr->ia_valid & ATTR_SIZE) &&
608 609
	    iattr->ia_size != i_size_read(inode))
		truncate_setsize(inode, iattr->ia_size);
610

611 612 613
	v9fs_invalidate_inode_attr(inode);
	setattr_copy(inode, iattr);
	mark_inode_dirty(inode);
614 615
	if (iattr->ia_valid & ATTR_MODE) {
		/* We also want to update ACL when we update mode bits */
616
		retval = v9fs_acl_chmod(inode, fid);
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
		if (retval < 0)
			return retval;
	}
	return 0;
}

/**
 * v9fs_stat2inode_dotl - populate an inode structure with stat info
 * @stat: stat structure
 * @inode: inode to populate
 * @sb: superblock of filesystem
 *
 */

void
v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
{
A
Al Viro 已提交
634
	umode_t mode;
635
	struct v9fs_inode *v9inode = V9FS_I(inode);
636 637 638 639 640 641 642 643 644 645

	if ((stat->st_result_mask & P9_STATS_BASIC) == P9_STATS_BASIC) {
		inode->i_atime.tv_sec = stat->st_atime_sec;
		inode->i_atime.tv_nsec = stat->st_atime_nsec;
		inode->i_mtime.tv_sec = stat->st_mtime_sec;
		inode->i_mtime.tv_nsec = stat->st_mtime_nsec;
		inode->i_ctime.tv_sec = stat->st_ctime_sec;
		inode->i_ctime.tv_nsec = stat->st_ctime_nsec;
		inode->i_uid = stat->st_uid;
		inode->i_gid = stat->st_gid;
M
Miklos Szeredi 已提交
646
		set_nlink(inode, stat->st_nlink);
647

648 649 650
		mode = stat->st_mode & S_IALLUGO;
		mode |= inode->i_mode & ~S_IALLUGO;
		inode->i_mode = mode;
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671

		i_size_write(inode, stat->st_size);
		inode->i_blocks = stat->st_blocks;
	} else {
		if (stat->st_result_mask & P9_STATS_ATIME) {
			inode->i_atime.tv_sec = stat->st_atime_sec;
			inode->i_atime.tv_nsec = stat->st_atime_nsec;
		}
		if (stat->st_result_mask & P9_STATS_MTIME) {
			inode->i_mtime.tv_sec = stat->st_mtime_sec;
			inode->i_mtime.tv_nsec = stat->st_mtime_nsec;
		}
		if (stat->st_result_mask & P9_STATS_CTIME) {
			inode->i_ctime.tv_sec = stat->st_ctime_sec;
			inode->i_ctime.tv_nsec = stat->st_ctime_nsec;
		}
		if (stat->st_result_mask & P9_STATS_UID)
			inode->i_uid = stat->st_uid;
		if (stat->st_result_mask & P9_STATS_GID)
			inode->i_gid = stat->st_gid;
		if (stat->st_result_mask & P9_STATS_NLINK)
M
Miklos Szeredi 已提交
672
			set_nlink(inode, stat->st_nlink);
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
		if (stat->st_result_mask & P9_STATS_MODE) {
			inode->i_mode = stat->st_mode;
			if ((S_ISBLK(inode->i_mode)) ||
						(S_ISCHR(inode->i_mode)))
				init_special_inode(inode, inode->i_mode,
								inode->i_rdev);
		}
		if (stat->st_result_mask & P9_STATS_RDEV)
			inode->i_rdev = new_decode_dev(stat->st_rdev);
		if (stat->st_result_mask & P9_STATS_SIZE)
			i_size_write(inode, stat->st_size);
		if (stat->st_result_mask & P9_STATS_BLOCKS)
			inode->i_blocks = stat->st_blocks;
	}
	if (stat->st_result_mask & P9_STATS_GEN)
688
		inode->i_generation = stat->st_gen;
689 690 691 692

	/* Currently we don't support P9_STATS_BTIME and P9_STATS_DATA_VERSION
	 * because the inode structure does not have fields for them.
	 */
693
	v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
694 695 696 697 698 699 700
}

static int
v9fs_vfs_symlink_dotl(struct inode *dir, struct dentry *dentry,
		const char *symname)
{
	int err;
701
	kgid_t gid;
702 703 704 705 706 707
	char *name;
	struct p9_qid qid;
	struct inode *inode;
	struct p9_fid *dfid;
	struct p9_fid *fid = NULL;
	struct v9fs_session_info *v9ses;
708 709

	name = (char *) dentry->d_name.name;
710
	p9_debug(P9_DEBUG_VFS, "%lu,%s,%s\n", dir->i_ino, name, symname);
711 712 713 714 715
	v9ses = v9fs_inode2v9ses(dir);

	dfid = v9fs_fid_lookup(dentry->d_parent);
	if (IS_ERR(dfid)) {
		err = PTR_ERR(dfid);
716
		p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
717 718 719 720 721 722 723 724 725
		return err;
	}

	gid = v9fs_get_fsgid_for_create(dir);

	/* Server doesn't alter fid on TSYMLINK. Hence no need to clone it. */
	err = p9_client_symlink(dfid, name, (char *)symname, gid, &qid);

	if (err < 0) {
726
		p9_debug(P9_DEBUG_VFS, "p9_client_symlink failed %d\n", err);
727 728 729
		goto error;
	}

730
	v9fs_invalidate_inode_attr(dir);
731 732 733 734 735
	if (v9ses->cache) {
		/* Now walk from the parent so we can get an unopened fid. */
		fid = p9_client_walk(dfid, 1, &name, 1);
		if (IS_ERR(fid)) {
			err = PTR_ERR(fid);
736 737
			p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
				 err);
738 739 740 741 742
			fid = NULL;
			goto error;
		}

		/* instantiate inode and assign the unopened fid to dentry */
743
		inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
744 745
		if (IS_ERR(inode)) {
			err = PTR_ERR(inode);
746 747
			p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n",
				 err);
748 749 750 751 752
			goto error;
		}
		err = v9fs_fid_add(dentry, fid);
		if (err < 0)
			goto error;
753
		d_instantiate(dentry, inode);
754 755 756
		fid = NULL;
	} else {
		/* Not in cached mode. No need to populate inode with stat */
757
		inode = v9fs_get_inode(dir->i_sb, S_IFLNK, 0);
758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786
		if (IS_ERR(inode)) {
			err = PTR_ERR(inode);
			goto error;
		}
		d_instantiate(dentry, inode);
	}

error:
	if (fid)
		p9_client_clunk(fid);

	return err;
}

/**
 * v9fs_vfs_link_dotl - create a hardlink for dotl
 * @old_dentry: dentry for file to link to
 * @dir: inode destination for new link
 * @dentry: dentry for link
 *
 */

static int
v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
		struct dentry *dentry)
{
	int err;
	char *name;
	struct dentry *dir_dentry;
787 788
	struct p9_fid *dfid, *oldfid;
	struct v9fs_session_info *v9ses;
789

790 791
	p9_debug(P9_DEBUG_VFS, "dir ino: %lu, old_name: %s, new_name: %s\n",
		 dir->i_ino, old_dentry->d_name.name, dentry->d_name.name);
792 793

	v9ses = v9fs_inode2v9ses(dir);
A
Al Viro 已提交
794
	dir_dentry = dentry->d_parent;
795 796 797 798 799 800 801 802 803 804 805 806 807
	dfid = v9fs_fid_lookup(dir_dentry);
	if (IS_ERR(dfid))
		return PTR_ERR(dfid);

	oldfid = v9fs_fid_lookup(old_dentry);
	if (IS_ERR(oldfid))
		return PTR_ERR(oldfid);

	name = (char *) dentry->d_name.name;

	err = p9_client_link(dfid, oldfid, (char *)dentry->d_name.name);

	if (err < 0) {
808
		p9_debug(P9_DEBUG_VFS, "p9_client_link failed %d\n", err);
809 810 811
		return err;
	}

812
	v9fs_invalidate_inode_attr(dir);
813 814 815 816 817 818 819
	if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
		/* Get the latest stat info from server. */
		struct p9_fid *fid;
		fid = v9fs_fid_lookup(old_dentry);
		if (IS_ERR(fid))
			return PTR_ERR(fid);

820
		v9fs_refresh_inode_dotl(fid, old_dentry->d_inode);
821
	}
822
	ihold(old_dentry->d_inode);
823 824 825 826 827 828 829 830 831 832 833 834 835 836
	d_instantiate(dentry, old_dentry->d_inode);

	return err;
}

/**
 * v9fs_vfs_mknod_dotl - create a special file
 * @dir: inode destination for new link
 * @dentry: dentry for file
 * @mode: mode for creation
 * @rdev: device associated with special file
 *
 */
static int
A
Al Viro 已提交
837
v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
838 839 840
		dev_t rdev)
{
	int err;
841
	kgid_t gid;
842
	char *name;
A
Al Viro 已提交
843
	umode_t mode;
844 845 846 847 848 849 850
	struct v9fs_session_info *v9ses;
	struct p9_fid *fid = NULL, *dfid = NULL;
	struct inode *inode;
	struct p9_qid qid;
	struct dentry *dir_dentry;
	struct posix_acl *dacl = NULL, *pacl = NULL;

851
	p9_debug(P9_DEBUG_VFS, " %lu,%s mode: %hx MAJOR: %u MINOR: %u\n",
852 853
		 dir->i_ino, dentry->d_name.name, omode,
		 MAJOR(rdev), MINOR(rdev));
854 855 856 857 858

	if (!new_valid_dev(rdev))
		return -EINVAL;

	v9ses = v9fs_inode2v9ses(dir);
A
Al Viro 已提交
859
	dir_dentry = dentry->d_parent;
860 861 862
	dfid = v9fs_fid_lookup(dir_dentry);
	if (IS_ERR(dfid)) {
		err = PTR_ERR(dfid);
863
		p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
864 865 866 867 868 869 870 871 872
		dfid = NULL;
		goto error;
	}

	gid = v9fs_get_fsgid_for_create(dir);
	mode = omode;
	/* Update mode based on ACL value */
	err = v9fs_acl_mode(dir, &mode, &dacl, &pacl);
	if (err) {
873 874
		p9_debug(P9_DEBUG_VFS, "Failed to get acl values in mknod %d\n",
			 err);
875 876 877 878 879 880 881 882
		goto error;
	}
	name = (char *) dentry->d_name.name;

	err = p9_client_mknod_dotl(dfid, name, mode, rdev, gid, &qid);
	if (err < 0)
		goto error;

883
	v9fs_invalidate_inode_attr(dir);
884 885 886 887 888 889 890 891 892
	fid = p9_client_walk(dfid, 1, &name, 1);
	if (IS_ERR(fid)) {
		err = PTR_ERR(fid);
		p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
			 err);
		fid = NULL;
		goto error;
	}

893 894
	/* instantiate inode and assign the unopened fid to the dentry */
	if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
895
		inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
896 897
		if (IS_ERR(inode)) {
			err = PTR_ERR(inode);
898 899
			p9_debug(P9_DEBUG_VFS, "inode creation failed %d\n",
				 err);
900 901
			goto error;
		}
902
		v9fs_set_create_acl(inode, fid, dacl, pacl);
903 904 905
		err = v9fs_fid_add(dentry, fid);
		if (err < 0)
			goto error;
906
		d_instantiate(dentry, inode);
907 908 909 910 911 912
		fid = NULL;
	} else {
		/*
		 * Not in cached mode. No need to populate inode with stat.
		 * socket syscall returns a fd, so we need instantiate
		 */
913
		inode = v9fs_get_inode(dir->i_sb, mode, rdev);
914 915 916 917
		if (IS_ERR(inode)) {
			err = PTR_ERR(inode);
			goto error;
		}
918
		v9fs_set_create_acl(inode, fid, dacl, pacl);
919 920 921 922 923
		d_instantiate(dentry, inode);
	}
error:
	if (fid)
		p9_client_clunk(fid);
924
	v9fs_put_acl(dacl, pacl);
925 926 927 928 929 930 931 932 933 934 935 936 937
	return err;
}

/**
 * v9fs_vfs_follow_link_dotl - follow a symlink path
 * @dentry: dentry for symlink
 * @nd: nameidata
 *
 */

static void *
v9fs_vfs_follow_link_dotl(struct dentry *dentry, struct nameidata *nd)
{
M
M. Mohan Kumar 已提交
938 939
	int retval;
	struct p9_fid *fid;
940
	char *link = __getname();
M
M. Mohan Kumar 已提交
941
	char *target;
942

943
	p9_debug(P9_DEBUG_VFS, "%s\n", dentry->d_name.name);
944

M
M. Mohan Kumar 已提交
945
	if (!link) {
946
		link = ERR_PTR(-ENOMEM);
M
M. Mohan Kumar 已提交
947
		goto ndset;
948
	}
M
M. Mohan Kumar 已提交
949 950 951
	fid = v9fs_fid_lookup(dentry);
	if (IS_ERR(fid)) {
		__putname(link);
952
		link = ERR_CAST(fid);
M
M. Mohan Kumar 已提交
953 954 955 956 957 958 959 960 961 962 963
		goto ndset;
	}
	retval = p9_client_readlink(fid, &target);
	if (!retval) {
		strcpy(link, target);
		kfree(target);
		goto ndset;
	}
	__putname(link);
	link = ERR_PTR(retval);
ndset:
964 965 966 967
	nd_set_link(nd, link);
	return NULL;
}

968 969 970 971 972 973 974 975 976 977
int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode)
{
	loff_t i_size;
	struct p9_stat_dotl *st;
	struct v9fs_session_info *v9ses;

	v9ses = v9fs_inode2v9ses(inode);
	st = p9_client_getattr_dotl(fid, P9_STATS_ALL);
	if (IS_ERR(st))
		return PTR_ERR(st);
978 979 980 981 982
	/*
	 * Don't update inode if the file type is different
	 */
	if ((inode->i_mode & S_IFMT) != (st->st_mode & S_IFMT))
		goto out;
983 984 985 986 987 988 989 990 991 992 993

	spin_lock(&inode->i_lock);
	/*
	 * We don't want to refresh inode->i_size,
	 * because we may have cached data
	 */
	i_size = inode->i_size;
	v9fs_stat2inode_dotl(st, inode);
	if (v9ses->cache)
		inode->i_size = i_size;
	spin_unlock(&inode->i_lock);
994
out:
995 996 997 998
	kfree(st);
	return 0;
}

999 1000
const struct inode_operations v9fs_dir_inode_operations_dotl = {
	.create = v9fs_vfs_create_dotl,
1001
	.atomic_open = v9fs_vfs_atomic_open_dotl,
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
	.lookup = v9fs_vfs_lookup,
	.link = v9fs_vfs_link_dotl,
	.symlink = v9fs_vfs_symlink_dotl,
	.unlink = v9fs_vfs_unlink,
	.mkdir = v9fs_vfs_mkdir_dotl,
	.rmdir = v9fs_vfs_rmdir,
	.mknod = v9fs_vfs_mknod_dotl,
	.rename = v9fs_vfs_rename,
	.getattr = v9fs_vfs_getattr_dotl,
	.setattr = v9fs_vfs_setattr_dotl,
	.setxattr = generic_setxattr,
	.getxattr = generic_getxattr,
	.removexattr = generic_removexattr,
	.listxattr = v9fs_listxattr,
1016
	.get_acl = v9fs_iop_get_acl,
1017 1018 1019 1020 1021 1022 1023 1024 1025
};

const struct inode_operations v9fs_file_inode_operations_dotl = {
	.getattr = v9fs_vfs_getattr_dotl,
	.setattr = v9fs_vfs_setattr_dotl,
	.setxattr = generic_setxattr,
	.getxattr = generic_getxattr,
	.removexattr = generic_removexattr,
	.listxattr = v9fs_listxattr,
1026
	.get_acl = v9fs_iop_get_acl,
1027 1028 1029
};

const struct inode_operations v9fs_symlink_inode_operations_dotl = {
M
M. Mohan Kumar 已提交
1030
	.readlink = generic_readlink,
1031 1032 1033 1034 1035 1036 1037 1038 1039
	.follow_link = v9fs_vfs_follow_link_dotl,
	.put_link = v9fs_vfs_put_link,
	.getattr = v9fs_vfs_getattr_dotl,
	.setattr = v9fs_vfs_setattr_dotl,
	.setxattr = generic_setxattr,
	.getxattr = generic_getxattr,
	.removexattr = generic_removexattr,
	.listxattr = v9fs_listxattr,
};