1 /*
2  *   Copyright (C) International Business Machines Corp., 2000-2004
3  *   Portions Copyright (C) Christoph Hellwig, 2001-2002
4  *
5  *   This program is free software;  you can redistribute it and/or modify
6  *   it under the terms of the GNU General Public License as published by
7  *   the Free Software Foundation; either version 2 of the License, or
8  *   (at your option) any later version.
9  *
10  *   This program is distributed in the hope that it will be useful,
11  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
13  *   the GNU General Public License for more details.
14  *
15  *   You should have received a copy of the GNU General Public License
16  *   along with this program;  if not, write to the Free Software
17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  */
19 
20 #include <linux/fs.h>
21 #include <linux/namei.h>
22 #include <linux/ctype.h>
23 #include <linux/quotaops.h>
24 #include <linux/exportfs.h>
25 #include "jfs_incore.h"
26 #include "jfs_superblock.h"
27 #include "jfs_inode.h"
28 #include "jfs_dinode.h"
29 #include "jfs_dmap.h"
30 #include "jfs_unicode.h"
31 #include "jfs_metapage.h"
32 #include "jfs_xattr.h"
33 #include "jfs_acl.h"
34 #include "jfs_debug.h"
35 
36 /*
37  * forward references
38  */
39 const struct dentry_operations jfs_ci_dentry_operations;
40 
41 static s64 commitZeroLink(tid_t, struct inode *);
42 
43 /*
44  * NAME:	free_ea_wmap(inode)
45  *
46  * FUNCTION:	free uncommitted extended attributes from working map
47  *
48  */
free_ea_wmap(struct inode * inode)49 static inline void free_ea_wmap(struct inode *inode)
50 {
51 	dxd_t *ea = &JFS_IP(inode)->ea;
52 
53 	if (ea->flag & DXD_EXTENT) {
54 		/* free EA pages from cache */
55 		invalidate_dxd_metapages(inode, *ea);
56 		dbFree(inode, addressDXD(ea), lengthDXD(ea));
57 	}
58 	ea->flag = 0;
59 }
60 
61 /*
62  * NAME:	jfs_create(dip, dentry, mode)
63  *
64  * FUNCTION:	create a regular file in the parent directory <dip>
65  *		with name = <from dentry> and mode = <mode>
66  *
67  * PARAMETER:	dip	- parent directory vnode
68  *		dentry	- dentry of new file
69  *		mode	- create mode (rwxrwxrwx).
70  *		nd- nd struct
71  *
72  * RETURN:	Errors from subroutines
73  *
74  */
jfs_create(struct inode * dip,struct dentry * dentry,umode_t mode,struct nameidata * nd)75 static int jfs_create(struct inode *dip, struct dentry *dentry, umode_t mode,
76 		struct nameidata *nd)
77 {
78 	int rc = 0;
79 	tid_t tid;		/* transaction id */
80 	struct inode *ip = NULL;	/* child directory inode */
81 	ino_t ino;
82 	struct component_name dname;	/* child directory name */
83 	struct btstack btstack;
84 	struct inode *iplist[2];
85 	struct tblock *tblk;
86 
87 	jfs_info("jfs_create: dip:0x%p name:%s", dip, dentry->d_name.name);
88 
89 	dquot_initialize(dip);
90 
91 	/*
92 	 * search parent directory for entry/freespace
93 	 * (dtSearch() returns parent directory page pinned)
94 	 */
95 	if ((rc = get_UCSname(&dname, dentry)))
96 		goto out1;
97 
98 	/*
99 	 * Either iAlloc() or txBegin() may block.  Deadlock can occur if we
100 	 * block there while holding dtree page, so we allocate the inode &
101 	 * begin the transaction before we search the directory.
102 	 */
103 	ip = ialloc(dip, mode);
104 	if (IS_ERR(ip)) {
105 		rc = PTR_ERR(ip);
106 		goto out2;
107 	}
108 
109 	tid = txBegin(dip->i_sb, 0);
110 
111 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
112 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
113 
114 	rc = jfs_init_acl(tid, ip, dip);
115 	if (rc)
116 		goto out3;
117 
118 	rc = jfs_init_security(tid, ip, dip, &dentry->d_name);
119 	if (rc) {
120 		txAbort(tid, 0);
121 		goto out3;
122 	}
123 
124 	if ((rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE))) {
125 		jfs_err("jfs_create: dtSearch returned %d", rc);
126 		txAbort(tid, 0);
127 		goto out3;
128 	}
129 
130 	tblk = tid_to_tblock(tid);
131 	tblk->xflag |= COMMIT_CREATE;
132 	tblk->ino = ip->i_ino;
133 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
134 
135 	iplist[0] = dip;
136 	iplist[1] = ip;
137 
138 	/*
139 	 * initialize the child XAD tree root in-line in inode
140 	 */
141 	xtInitRoot(tid, ip);
142 
143 	/*
144 	 * create entry in parent directory for child directory
145 	 * (dtInsert() releases parent directory page)
146 	 */
147 	ino = ip->i_ino;
148 	if ((rc = dtInsert(tid, dip, &dname, &ino, &btstack))) {
149 		if (rc == -EIO) {
150 			jfs_err("jfs_create: dtInsert returned -EIO");
151 			txAbort(tid, 1);	/* Marks Filesystem dirty */
152 		} else
153 			txAbort(tid, 0);	/* Filesystem full */
154 		goto out3;
155 	}
156 
157 	ip->i_op = &jfs_file_inode_operations;
158 	ip->i_fop = &jfs_file_operations;
159 	ip->i_mapping->a_ops = &jfs_aops;
160 
161 	mark_inode_dirty(ip);
162 
163 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
164 
165 	mark_inode_dirty(dip);
166 
167 	rc = txCommit(tid, 2, &iplist[0], 0);
168 
169       out3:
170 	txEnd(tid);
171 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
172 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
173 	if (rc) {
174 		free_ea_wmap(ip);
175 		clear_nlink(ip);
176 		unlock_new_inode(ip);
177 		iput(ip);
178 	} else {
179 		d_instantiate(dentry, ip);
180 		unlock_new_inode(ip);
181 	}
182 
183       out2:
184 	free_UCSname(&dname);
185 
186       out1:
187 
188 	jfs_info("jfs_create: rc:%d", rc);
189 	return rc;
190 }
191 
192 
193 /*
194  * NAME:	jfs_mkdir(dip, dentry, mode)
195  *
196  * FUNCTION:	create a child directory in the parent directory <dip>
197  *		with name = <from dentry> and mode = <mode>
198  *
199  * PARAMETER:	dip	- parent directory vnode
200  *		dentry	- dentry of child directory
201  *		mode	- create mode (rwxrwxrwx).
202  *
203  * RETURN:	Errors from subroutines
204  *
205  * note:
206  * EACCESS: user needs search+write permission on the parent directory
207  */
jfs_mkdir(struct inode * dip,struct dentry * dentry,umode_t mode)208 static int jfs_mkdir(struct inode *dip, struct dentry *dentry, umode_t mode)
209 {
210 	int rc = 0;
211 	tid_t tid;		/* transaction id */
212 	struct inode *ip = NULL;	/* child directory inode */
213 	ino_t ino;
214 	struct component_name dname;	/* child directory name */
215 	struct btstack btstack;
216 	struct inode *iplist[2];
217 	struct tblock *tblk;
218 
219 	jfs_info("jfs_mkdir: dip:0x%p name:%s", dip, dentry->d_name.name);
220 
221 	dquot_initialize(dip);
222 
223 	/*
224 	 * search parent directory for entry/freespace
225 	 * (dtSearch() returns parent directory page pinned)
226 	 */
227 	if ((rc = get_UCSname(&dname, dentry)))
228 		goto out1;
229 
230 	/*
231 	 * Either iAlloc() or txBegin() may block.  Deadlock can occur if we
232 	 * block there while holding dtree page, so we allocate the inode &
233 	 * begin the transaction before we search the directory.
234 	 */
235 	ip = ialloc(dip, S_IFDIR | mode);
236 	if (IS_ERR(ip)) {
237 		rc = PTR_ERR(ip);
238 		goto out2;
239 	}
240 
241 	tid = txBegin(dip->i_sb, 0);
242 
243 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
244 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
245 
246 	rc = jfs_init_acl(tid, ip, dip);
247 	if (rc)
248 		goto out3;
249 
250 	rc = jfs_init_security(tid, ip, dip, &dentry->d_name);
251 	if (rc) {
252 		txAbort(tid, 0);
253 		goto out3;
254 	}
255 
256 	if ((rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE))) {
257 		jfs_err("jfs_mkdir: dtSearch returned %d", rc);
258 		txAbort(tid, 0);
259 		goto out3;
260 	}
261 
262 	tblk = tid_to_tblock(tid);
263 	tblk->xflag |= COMMIT_CREATE;
264 	tblk->ino = ip->i_ino;
265 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
266 
267 	iplist[0] = dip;
268 	iplist[1] = ip;
269 
270 	/*
271 	 * initialize the child directory in-line in inode
272 	 */
273 	dtInitRoot(tid, ip, dip->i_ino);
274 
275 	/*
276 	 * create entry in parent directory for child directory
277 	 * (dtInsert() releases parent directory page)
278 	 */
279 	ino = ip->i_ino;
280 	if ((rc = dtInsert(tid, dip, &dname, &ino, &btstack))) {
281 		if (rc == -EIO) {
282 			jfs_err("jfs_mkdir: dtInsert returned -EIO");
283 			txAbort(tid, 1);	/* Marks Filesystem dirty */
284 		} else
285 			txAbort(tid, 0);	/* Filesystem full */
286 		goto out3;
287 	}
288 
289 	set_nlink(ip, 2);	/* for '.' */
290 	ip->i_op = &jfs_dir_inode_operations;
291 	ip->i_fop = &jfs_dir_operations;
292 
293 	mark_inode_dirty(ip);
294 
295 	/* update parent directory inode */
296 	inc_nlink(dip);		/* for '..' from child directory */
297 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
298 	mark_inode_dirty(dip);
299 
300 	rc = txCommit(tid, 2, &iplist[0], 0);
301 
302       out3:
303 	txEnd(tid);
304 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
305 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
306 	if (rc) {
307 		free_ea_wmap(ip);
308 		clear_nlink(ip);
309 		unlock_new_inode(ip);
310 		iput(ip);
311 	} else {
312 		d_instantiate(dentry, ip);
313 		unlock_new_inode(ip);
314 	}
315 
316       out2:
317 	free_UCSname(&dname);
318 
319 
320       out1:
321 
322 	jfs_info("jfs_mkdir: rc:%d", rc);
323 	return rc;
324 }
325 
326 /*
327  * NAME:	jfs_rmdir(dip, dentry)
328  *
329  * FUNCTION:	remove a link to child directory
330  *
331  * PARAMETER:	dip	- parent inode
332  *		dentry	- child directory dentry
333  *
334  * RETURN:	-EINVAL	- if name is . or ..
335  *		-EINVAL - if . or .. exist but are invalid.
336  *		errors from subroutines
337  *
338  * note:
339  * if other threads have the directory open when the last link
340  * is removed, the "." and ".." entries, if present, are removed before
341  * rmdir() returns and no new entries may be created in the directory,
342  * but the directory is not removed until the last reference to
343  * the directory is released (cf.unlink() of regular file).
344  */
jfs_rmdir(struct inode * dip,struct dentry * dentry)345 static int jfs_rmdir(struct inode *dip, struct dentry *dentry)
346 {
347 	int rc;
348 	tid_t tid;		/* transaction id */
349 	struct inode *ip = dentry->d_inode;
350 	ino_t ino;
351 	struct component_name dname;
352 	struct inode *iplist[2];
353 	struct tblock *tblk;
354 
355 	jfs_info("jfs_rmdir: dip:0x%p name:%s", dip, dentry->d_name.name);
356 
357 	/* Init inode for quota operations. */
358 	dquot_initialize(dip);
359 	dquot_initialize(ip);
360 
361 	/* directory must be empty to be removed */
362 	if (!dtEmpty(ip)) {
363 		rc = -ENOTEMPTY;
364 		goto out;
365 	}
366 
367 	if ((rc = get_UCSname(&dname, dentry))) {
368 		goto out;
369 	}
370 
371 	tid = txBegin(dip->i_sb, 0);
372 
373 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
374 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
375 
376 	iplist[0] = dip;
377 	iplist[1] = ip;
378 
379 	tblk = tid_to_tblock(tid);
380 	tblk->xflag |= COMMIT_DELETE;
381 	tblk->u.ip = ip;
382 
383 	/*
384 	 * delete the entry of target directory from parent directory
385 	 */
386 	ino = ip->i_ino;
387 	if ((rc = dtDelete(tid, dip, &dname, &ino, JFS_REMOVE))) {
388 		jfs_err("jfs_rmdir: dtDelete returned %d", rc);
389 		if (rc == -EIO)
390 			txAbort(tid, 1);
391 		txEnd(tid);
392 		mutex_unlock(&JFS_IP(ip)->commit_mutex);
393 		mutex_unlock(&JFS_IP(dip)->commit_mutex);
394 
395 		goto out2;
396 	}
397 
398 	/* update parent directory's link count corresponding
399 	 * to ".." entry of the target directory deleted
400 	 */
401 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
402 	inode_dec_link_count(dip);
403 
404 	/*
405 	 * OS/2 could have created EA and/or ACL
406 	 */
407 	/* free EA from both persistent and working map */
408 	if (JFS_IP(ip)->ea.flag & DXD_EXTENT) {
409 		/* free EA pages */
410 		txEA(tid, ip, &JFS_IP(ip)->ea, NULL);
411 	}
412 	JFS_IP(ip)->ea.flag = 0;
413 
414 	/* free ACL from both persistent and working map */
415 	if (JFS_IP(ip)->acl.flag & DXD_EXTENT) {
416 		/* free ACL pages */
417 		txEA(tid, ip, &JFS_IP(ip)->acl, NULL);
418 	}
419 	JFS_IP(ip)->acl.flag = 0;
420 
421 	/* mark the target directory as deleted */
422 	clear_nlink(ip);
423 	mark_inode_dirty(ip);
424 
425 	rc = txCommit(tid, 2, &iplist[0], 0);
426 
427 	txEnd(tid);
428 
429 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
430 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
431 
432 	/*
433 	 * Truncating the directory index table is not guaranteed.  It
434 	 * may need to be done iteratively
435 	 */
436 	if (test_cflag(COMMIT_Stale, dip)) {
437 		if (dip->i_size > 1)
438 			jfs_truncate_nolock(dip, 0);
439 
440 		clear_cflag(COMMIT_Stale, dip);
441 	}
442 
443       out2:
444 	free_UCSname(&dname);
445 
446       out:
447 	jfs_info("jfs_rmdir: rc:%d", rc);
448 	return rc;
449 }
450 
451 /*
452  * NAME:	jfs_unlink(dip, dentry)
453  *
454  * FUNCTION:	remove a link to object <vp> named by <name>
455  *		from parent directory <dvp>
456  *
457  * PARAMETER:	dip	- inode of parent directory
458  *		dentry	- dentry of object to be removed
459  *
460  * RETURN:	errors from subroutines
461  *
462  * note:
463  * temporary file: if one or more processes have the file open
464  * when the last link is removed, the link will be removed before
465  * unlink() returns, but the removal of the file contents will be
466  * postponed until all references to the files are closed.
467  *
468  * JFS does NOT support unlink() on directories.
469  *
470  */
jfs_unlink(struct inode * dip,struct dentry * dentry)471 static int jfs_unlink(struct inode *dip, struct dentry *dentry)
472 {
473 	int rc;
474 	tid_t tid;		/* transaction id */
475 	struct inode *ip = dentry->d_inode;
476 	ino_t ino;
477 	struct component_name dname;	/* object name */
478 	struct inode *iplist[2];
479 	struct tblock *tblk;
480 	s64 new_size = 0;
481 	int commit_flag;
482 
483 	jfs_info("jfs_unlink: dip:0x%p name:%s", dip, dentry->d_name.name);
484 
485 	/* Init inode for quota operations. */
486 	dquot_initialize(dip);
487 	dquot_initialize(ip);
488 
489 	if ((rc = get_UCSname(&dname, dentry)))
490 		goto out;
491 
492 	IWRITE_LOCK(ip, RDWRLOCK_NORMAL);
493 
494 	tid = txBegin(dip->i_sb, 0);
495 
496 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
497 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
498 
499 	iplist[0] = dip;
500 	iplist[1] = ip;
501 
502 	/*
503 	 * delete the entry of target file from parent directory
504 	 */
505 	ino = ip->i_ino;
506 	if ((rc = dtDelete(tid, dip, &dname, &ino, JFS_REMOVE))) {
507 		jfs_err("jfs_unlink: dtDelete returned %d", rc);
508 		if (rc == -EIO)
509 			txAbort(tid, 1);	/* Marks FS Dirty */
510 		txEnd(tid);
511 		mutex_unlock(&JFS_IP(ip)->commit_mutex);
512 		mutex_unlock(&JFS_IP(dip)->commit_mutex);
513 		IWRITE_UNLOCK(ip);
514 		goto out1;
515 	}
516 
517 	ASSERT(ip->i_nlink);
518 
519 	ip->i_ctime = dip->i_ctime = dip->i_mtime = CURRENT_TIME;
520 	mark_inode_dirty(dip);
521 
522 	/* update target's inode */
523 	inode_dec_link_count(ip);
524 
525 	/*
526 	 *	commit zero link count object
527 	 */
528 	if (ip->i_nlink == 0) {
529 		assert(!test_cflag(COMMIT_Nolink, ip));
530 		/* free block resources */
531 		if ((new_size = commitZeroLink(tid, ip)) < 0) {
532 			txAbort(tid, 1);	/* Marks FS Dirty */
533 			txEnd(tid);
534 			mutex_unlock(&JFS_IP(ip)->commit_mutex);
535 			mutex_unlock(&JFS_IP(dip)->commit_mutex);
536 			IWRITE_UNLOCK(ip);
537 			rc = new_size;
538 			goto out1;
539 		}
540 		tblk = tid_to_tblock(tid);
541 		tblk->xflag |= COMMIT_DELETE;
542 		tblk->u.ip = ip;
543 	}
544 
545 	/*
546 	 * Incomplete truncate of file data can
547 	 * result in timing problems unless we synchronously commit the
548 	 * transaction.
549 	 */
550 	if (new_size)
551 		commit_flag = COMMIT_SYNC;
552 	else
553 		commit_flag = 0;
554 
555 	/*
556 	 * If xtTruncate was incomplete, commit synchronously to avoid
557 	 * timing complications
558 	 */
559 	rc = txCommit(tid, 2, &iplist[0], commit_flag);
560 
561 	txEnd(tid);
562 
563 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
564 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
565 
566 	while (new_size && (rc == 0)) {
567 		tid = txBegin(dip->i_sb, 0);
568 		mutex_lock(&JFS_IP(ip)->commit_mutex);
569 		new_size = xtTruncate_pmap(tid, ip, new_size);
570 		if (new_size < 0) {
571 			txAbort(tid, 1);	/* Marks FS Dirty */
572 			rc = new_size;
573 		} else
574 			rc = txCommit(tid, 2, &iplist[0], COMMIT_SYNC);
575 		txEnd(tid);
576 		mutex_unlock(&JFS_IP(ip)->commit_mutex);
577 	}
578 
579 	if (ip->i_nlink == 0)
580 		set_cflag(COMMIT_Nolink, ip);
581 
582 	IWRITE_UNLOCK(ip);
583 
584 	/*
585 	 * Truncating the directory index table is not guaranteed.  It
586 	 * may need to be done iteratively
587 	 */
588 	if (test_cflag(COMMIT_Stale, dip)) {
589 		if (dip->i_size > 1)
590 			jfs_truncate_nolock(dip, 0);
591 
592 		clear_cflag(COMMIT_Stale, dip);
593 	}
594 
595       out1:
596 	free_UCSname(&dname);
597       out:
598 	jfs_info("jfs_unlink: rc:%d", rc);
599 	return rc;
600 }
601 
602 /*
603  * NAME:	commitZeroLink()
604  *
605  * FUNCTION:	for non-directory, called by jfs_remove(),
606  *		truncate a regular file, directory or symbolic
607  *		link to zero length. return 0 if type is not
608  *		one of these.
609  *
610  *		if the file is currently associated with a VM segment
611  *		only permanent disk and inode map resources are freed,
612  *		and neither the inode nor indirect blocks are modified
613  *		so that the resources can be later freed in the work
614  *		map by ctrunc1.
615  *		if there is no VM segment on entry, the resources are
616  *		freed in both work and permanent map.
617  *		(? for temporary file - memory object is cached even
618  *		after no reference:
619  *		reference count > 0 -   )
620  *
621  * PARAMETERS:	cd	- pointer to commit data structure.
622  *			  current inode is the one to truncate.
623  *
624  * RETURN:	Errors from subroutines
625  */
commitZeroLink(tid_t tid,struct inode * ip)626 static s64 commitZeroLink(tid_t tid, struct inode *ip)
627 {
628 	int filetype;
629 	struct tblock *tblk;
630 
631 	jfs_info("commitZeroLink: tid = %d, ip = 0x%p", tid, ip);
632 
633 	filetype = ip->i_mode & S_IFMT;
634 	switch (filetype) {
635 	case S_IFREG:
636 		break;
637 	case S_IFLNK:
638 		/* fast symbolic link */
639 		if (ip->i_size < IDATASIZE) {
640 			ip->i_size = 0;
641 			return 0;
642 		}
643 		break;
644 	default:
645 		assert(filetype != S_IFDIR);
646 		return 0;
647 	}
648 
649 	set_cflag(COMMIT_Freewmap, ip);
650 
651 	/* mark transaction of block map update type */
652 	tblk = tid_to_tblock(tid);
653 	tblk->xflag |= COMMIT_PMAP;
654 
655 	/*
656 	 * free EA
657 	 */
658 	if (JFS_IP(ip)->ea.flag & DXD_EXTENT)
659 		/* acquire maplock on EA to be freed from block map */
660 		txEA(tid, ip, &JFS_IP(ip)->ea, NULL);
661 
662 	/*
663 	 * free ACL
664 	 */
665 	if (JFS_IP(ip)->acl.flag & DXD_EXTENT)
666 		/* acquire maplock on EA to be freed from block map */
667 		txEA(tid, ip, &JFS_IP(ip)->acl, NULL);
668 
669 	/*
670 	 * free xtree/data (truncate to zero length):
671 	 * free xtree/data pages from cache if COMMIT_PWMAP,
672 	 * free xtree/data blocks from persistent block map, and
673 	 * free xtree/data blocks from working block map if COMMIT_PWMAP;
674 	 */
675 	if (ip->i_size)
676 		return xtTruncate_pmap(tid, ip, 0);
677 
678 	return 0;
679 }
680 
681 
682 /*
683  * NAME:	jfs_free_zero_link()
684  *
685  * FUNCTION:	for non-directory, called by iClose(),
686  *		free resources of a file from cache and WORKING map
687  *		for a file previously committed with zero link count
688  *		while associated with a pager object,
689  *
690  * PARAMETER:	ip	- pointer to inode of file.
691  */
jfs_free_zero_link(struct inode * ip)692 void jfs_free_zero_link(struct inode *ip)
693 {
694 	int type;
695 
696 	jfs_info("jfs_free_zero_link: ip = 0x%p", ip);
697 
698 	/* return if not reg or symbolic link or if size is
699 	 * already ok.
700 	 */
701 	type = ip->i_mode & S_IFMT;
702 
703 	switch (type) {
704 	case S_IFREG:
705 		break;
706 	case S_IFLNK:
707 		/* if its contained in inode nothing to do */
708 		if (ip->i_size < IDATASIZE)
709 			return;
710 		break;
711 	default:
712 		return;
713 	}
714 
715 	/*
716 	 * free EA
717 	 */
718 	if (JFS_IP(ip)->ea.flag & DXD_EXTENT) {
719 		s64 xaddr = addressDXD(&JFS_IP(ip)->ea);
720 		int xlen = lengthDXD(&JFS_IP(ip)->ea);
721 		struct maplock maplock;	/* maplock for COMMIT_WMAP */
722 		struct pxd_lock *pxdlock;	/* maplock for COMMIT_WMAP */
723 
724 		/* free EA pages from cache */
725 		invalidate_dxd_metapages(ip, JFS_IP(ip)->ea);
726 
727 		/* free EA extent from working block map */
728 		maplock.index = 1;
729 		pxdlock = (struct pxd_lock *) & maplock;
730 		pxdlock->flag = mlckFREEPXD;
731 		PXDaddress(&pxdlock->pxd, xaddr);
732 		PXDlength(&pxdlock->pxd, xlen);
733 		txFreeMap(ip, pxdlock, NULL, COMMIT_WMAP);
734 	}
735 
736 	/*
737 	 * free ACL
738 	 */
739 	if (JFS_IP(ip)->acl.flag & DXD_EXTENT) {
740 		s64 xaddr = addressDXD(&JFS_IP(ip)->acl);
741 		int xlen = lengthDXD(&JFS_IP(ip)->acl);
742 		struct maplock maplock;	/* maplock for COMMIT_WMAP */
743 		struct pxd_lock *pxdlock;	/* maplock for COMMIT_WMAP */
744 
745 		invalidate_dxd_metapages(ip, JFS_IP(ip)->acl);
746 
747 		/* free ACL extent from working block map */
748 		maplock.index = 1;
749 		pxdlock = (struct pxd_lock *) & maplock;
750 		pxdlock->flag = mlckFREEPXD;
751 		PXDaddress(&pxdlock->pxd, xaddr);
752 		PXDlength(&pxdlock->pxd, xlen);
753 		txFreeMap(ip, pxdlock, NULL, COMMIT_WMAP);
754 	}
755 
756 	/*
757 	 * free xtree/data (truncate to zero length):
758 	 * free xtree/data pages from cache, and
759 	 * free xtree/data blocks from working block map;
760 	 */
761 	if (ip->i_size)
762 		xtTruncate(0, ip, 0, COMMIT_WMAP);
763 }
764 
765 /*
766  * NAME:	jfs_link(vp, dvp, name, crp)
767  *
768  * FUNCTION:	create a link to <vp> by the name = <name>
769  *		in the parent directory <dvp>
770  *
771  * PARAMETER:	vp	- target object
772  *		dvp	- parent directory of new link
773  *		name	- name of new link to target object
774  *		crp	- credential
775  *
776  * RETURN:	Errors from subroutines
777  *
778  * note:
779  * JFS does NOT support link() on directories (to prevent circular
780  * path in the directory hierarchy);
781  * EPERM: the target object is a directory, and either the caller
782  * does not have appropriate privileges or the implementation prohibits
783  * using link() on directories [XPG4.2].
784  *
785  * JFS does NOT support links between file systems:
786  * EXDEV: target object and new link are on different file systems and
787  * implementation does not support links between file systems [XPG4.2].
788  */
jfs_link(struct dentry * old_dentry,struct inode * dir,struct dentry * dentry)789 static int jfs_link(struct dentry *old_dentry,
790 	     struct inode *dir, struct dentry *dentry)
791 {
792 	int rc;
793 	tid_t tid;
794 	struct inode *ip = old_dentry->d_inode;
795 	ino_t ino;
796 	struct component_name dname;
797 	struct btstack btstack;
798 	struct inode *iplist[2];
799 
800 	jfs_info("jfs_link: %s %s", old_dentry->d_name.name,
801 		 dentry->d_name.name);
802 
803 	dquot_initialize(dir);
804 
805 	tid = txBegin(ip->i_sb, 0);
806 
807 	mutex_lock_nested(&JFS_IP(dir)->commit_mutex, COMMIT_MUTEX_PARENT);
808 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
809 
810 	/*
811 	 * scan parent directory for entry/freespace
812 	 */
813 	if ((rc = get_UCSname(&dname, dentry)))
814 		goto out;
815 
816 	if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE)))
817 		goto free_dname;
818 
819 	/*
820 	 * create entry for new link in parent directory
821 	 */
822 	ino = ip->i_ino;
823 	if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack)))
824 		goto free_dname;
825 
826 	/* update object inode */
827 	inc_nlink(ip);		/* for new link */
828 	ip->i_ctime = CURRENT_TIME;
829 	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
830 	mark_inode_dirty(dir);
831 	ihold(ip);
832 
833 	iplist[0] = ip;
834 	iplist[1] = dir;
835 	rc = txCommit(tid, 2, &iplist[0], 0);
836 
837 	if (rc) {
838 		drop_nlink(ip); /* never instantiated */
839 		iput(ip);
840 	} else
841 		d_instantiate(dentry, ip);
842 
843       free_dname:
844 	free_UCSname(&dname);
845 
846       out:
847 	txEnd(tid);
848 
849 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
850 	mutex_unlock(&JFS_IP(dir)->commit_mutex);
851 
852 	jfs_info("jfs_link: rc:%d", rc);
853 	return rc;
854 }
855 
856 /*
857  * NAME:	jfs_symlink(dip, dentry, name)
858  *
859  * FUNCTION:	creates a symbolic link to <symlink> by name <name>
860  *			in directory <dip>
861  *
862  * PARAMETER:	dip	- parent directory vnode
863  *		dentry	- dentry of symbolic link
864  *		name	- the path name of the existing object
865  *			  that will be the source of the link
866  *
867  * RETURN:	errors from subroutines
868  *
869  * note:
870  * ENAMETOOLONG: pathname resolution of a symbolic link produced
871  * an intermediate result whose length exceeds PATH_MAX [XPG4.2]
872 */
873 
jfs_symlink(struct inode * dip,struct dentry * dentry,const char * name)874 static int jfs_symlink(struct inode *dip, struct dentry *dentry,
875 		const char *name)
876 {
877 	int rc;
878 	tid_t tid;
879 	ino_t ino = 0;
880 	struct component_name dname;
881 	int ssize;		/* source pathname size */
882 	struct btstack btstack;
883 	struct inode *ip = dentry->d_inode;
884 	unchar *i_fastsymlink;
885 	s64 xlen = 0;
886 	int bmask = 0, xsize;
887 	s64 xaddr;
888 	struct metapage *mp;
889 	struct super_block *sb;
890 	struct tblock *tblk;
891 
892 	struct inode *iplist[2];
893 
894 	jfs_info("jfs_symlink: dip:0x%p name:%s", dip, name);
895 
896 	dquot_initialize(dip);
897 
898 	ssize = strlen(name) + 1;
899 
900 	/*
901 	 * search parent directory for entry/freespace
902 	 * (dtSearch() returns parent directory page pinned)
903 	 */
904 
905 	if ((rc = get_UCSname(&dname, dentry)))
906 		goto out1;
907 
908 	/*
909 	 * allocate on-disk/in-memory inode for symbolic link:
910 	 * (iAlloc() returns new, locked inode)
911 	 */
912 	ip = ialloc(dip, S_IFLNK | 0777);
913 	if (IS_ERR(ip)) {
914 		rc = PTR_ERR(ip);
915 		goto out2;
916 	}
917 
918 	tid = txBegin(dip->i_sb, 0);
919 
920 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
921 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
922 
923 	rc = jfs_init_security(tid, ip, dip, &dentry->d_name);
924 	if (rc)
925 		goto out3;
926 
927 	tblk = tid_to_tblock(tid);
928 	tblk->xflag |= COMMIT_CREATE;
929 	tblk->ino = ip->i_ino;
930 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
931 
932 	/* fix symlink access permission
933 	 * (dir_create() ANDs in the u.u_cmask,
934 	 * but symlinks really need to be 777 access)
935 	 */
936 	ip->i_mode |= 0777;
937 
938 	/*
939 	 * write symbolic link target path name
940 	 */
941 	xtInitRoot(tid, ip);
942 
943 	/*
944 	 * write source path name inline in on-disk inode (fast symbolic link)
945 	 */
946 
947 	if (ssize <= IDATASIZE) {
948 		ip->i_op = &jfs_fast_symlink_inode_operations;
949 
950 		i_fastsymlink = JFS_IP(ip)->i_inline;
951 		memcpy(i_fastsymlink, name, ssize);
952 		ip->i_size = ssize - 1;
953 
954 		/*
955 		 * if symlink is > 128 bytes, we don't have the space to
956 		 * store inline extended attributes
957 		 */
958 		if (ssize > sizeof (JFS_IP(ip)->i_inline))
959 			JFS_IP(ip)->mode2 &= ~INLINEEA;
960 
961 		jfs_info("jfs_symlink: fast symlink added  ssize:%d name:%s ",
962 			 ssize, name);
963 	}
964 	/*
965 	 * write source path name in a single extent
966 	 */
967 	else {
968 		jfs_info("jfs_symlink: allocate extent ip:0x%p", ip);
969 
970 		ip->i_op = &jfs_symlink_inode_operations;
971 		ip->i_mapping->a_ops = &jfs_aops;
972 
973 		/*
974 		 * even though the data of symlink object (source
975 		 * path name) is treated as non-journaled user data,
976 		 * it is read/written thru buffer cache for performance.
977 		 */
978 		sb = ip->i_sb;
979 		bmask = JFS_SBI(sb)->bsize - 1;
980 		xsize = (ssize + bmask) & ~bmask;
981 		xaddr = 0;
982 		xlen = xsize >> JFS_SBI(sb)->l2bsize;
983 		if ((rc = xtInsert(tid, ip, 0, 0, xlen, &xaddr, 0))) {
984 			txAbort(tid, 0);
985 			goto out3;
986 		}
987 		ip->i_size = ssize - 1;
988 		while (ssize) {
989 			/* This is kind of silly since PATH_MAX == 4K */
990 			int copy_size = min(ssize, PSIZE);
991 
992 			mp = get_metapage(ip, xaddr, PSIZE, 1);
993 
994 			if (mp == NULL) {
995 				xtTruncate(tid, ip, 0, COMMIT_PWMAP);
996 				rc = -EIO;
997 				txAbort(tid, 0);
998 				goto out3;
999 			}
1000 			memcpy(mp->data, name, copy_size);
1001 			flush_metapage(mp);
1002 			ssize -= copy_size;
1003 			name += copy_size;
1004 			xaddr += JFS_SBI(sb)->nbperpage;
1005 		}
1006 	}
1007 
1008 	/*
1009 	 * create entry for symbolic link in parent directory
1010 	 */
1011 	rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE);
1012 	if (rc == 0) {
1013 		ino = ip->i_ino;
1014 		rc = dtInsert(tid, dip, &dname, &ino, &btstack);
1015 	}
1016 	if (rc) {
1017 		if (xlen)
1018 			xtTruncate(tid, ip, 0, COMMIT_PWMAP);
1019 		txAbort(tid, 0);
1020 		/* discard new inode */
1021 		goto out3;
1022 	}
1023 
1024 	mark_inode_dirty(ip);
1025 
1026 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
1027 	mark_inode_dirty(dip);
1028 	/*
1029 	 * commit update of parent directory and link object
1030 	 */
1031 
1032 	iplist[0] = dip;
1033 	iplist[1] = ip;
1034 	rc = txCommit(tid, 2, &iplist[0], 0);
1035 
1036       out3:
1037 	txEnd(tid);
1038 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
1039 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
1040 	if (rc) {
1041 		free_ea_wmap(ip);
1042 		clear_nlink(ip);
1043 		unlock_new_inode(ip);
1044 		iput(ip);
1045 	} else {
1046 		d_instantiate(dentry, ip);
1047 		unlock_new_inode(ip);
1048 	}
1049 
1050       out2:
1051 	free_UCSname(&dname);
1052 
1053       out1:
1054 	jfs_info("jfs_symlink: rc:%d", rc);
1055 	return rc;
1056 }
1057 
1058 
1059 /*
1060  * NAME:	jfs_rename
1061  *
1062  * FUNCTION:	rename a file or directory
1063  */
jfs_rename(struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry)1064 static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1065 	       struct inode *new_dir, struct dentry *new_dentry)
1066 {
1067 	struct btstack btstack;
1068 	ino_t ino;
1069 	struct component_name new_dname;
1070 	struct inode *new_ip;
1071 	struct component_name old_dname;
1072 	struct inode *old_ip;
1073 	int rc;
1074 	tid_t tid;
1075 	struct tlock *tlck;
1076 	struct dt_lock *dtlck;
1077 	struct lv *lv;
1078 	int ipcount;
1079 	struct inode *iplist[4];
1080 	struct tblock *tblk;
1081 	s64 new_size = 0;
1082 	int commit_flag;
1083 
1084 
1085 	jfs_info("jfs_rename: %s %s", old_dentry->d_name.name,
1086 		 new_dentry->d_name.name);
1087 
1088 	dquot_initialize(old_dir);
1089 	dquot_initialize(new_dir);
1090 
1091 	old_ip = old_dentry->d_inode;
1092 	new_ip = new_dentry->d_inode;
1093 
1094 	if ((rc = get_UCSname(&old_dname, old_dentry)))
1095 		goto out1;
1096 
1097 	if ((rc = get_UCSname(&new_dname, new_dentry)))
1098 		goto out2;
1099 
1100 	/*
1101 	 * Make sure source inode number is what we think it is
1102 	 */
1103 	rc = dtSearch(old_dir, &old_dname, &ino, &btstack, JFS_LOOKUP);
1104 	if (rc || (ino != old_ip->i_ino)) {
1105 		rc = -ENOENT;
1106 		goto out3;
1107 	}
1108 
1109 	/*
1110 	 * Make sure dest inode number (if any) is what we think it is
1111 	 */
1112 	rc = dtSearch(new_dir, &new_dname, &ino, &btstack, JFS_LOOKUP);
1113 	if (!rc) {
1114 		if ((!new_ip) || (ino != new_ip->i_ino)) {
1115 			rc = -ESTALE;
1116 			goto out3;
1117 		}
1118 	} else if (rc != -ENOENT)
1119 		goto out3;
1120 	else if (new_ip) {
1121 		/* no entry exists, but one was expected */
1122 		rc = -ESTALE;
1123 		goto out3;
1124 	}
1125 
1126 	if (S_ISDIR(old_ip->i_mode)) {
1127 		if (new_ip) {
1128 			if (!dtEmpty(new_ip)) {
1129 				rc = -ENOTEMPTY;
1130 				goto out3;
1131 			}
1132 		}
1133 	} else if (new_ip) {
1134 		IWRITE_LOCK(new_ip, RDWRLOCK_NORMAL);
1135 		/* Init inode for quota operations. */
1136 		dquot_initialize(new_ip);
1137 	}
1138 
1139 	/*
1140 	 * The real work starts here
1141 	 */
1142 	tid = txBegin(new_dir->i_sb, 0);
1143 
1144 	/*
1145 	 * How do we know the locking is safe from deadlocks?
1146 	 * The vfs does the hard part for us.  Any time we are taking nested
1147 	 * commit_mutexes, the vfs already has i_mutex held on the parent.
1148 	 * Here, the vfs has already taken i_mutex on both old_dir and new_dir.
1149 	 */
1150 	mutex_lock_nested(&JFS_IP(new_dir)->commit_mutex, COMMIT_MUTEX_PARENT);
1151 	mutex_lock_nested(&JFS_IP(old_ip)->commit_mutex, COMMIT_MUTEX_CHILD);
1152 	if (old_dir != new_dir)
1153 		mutex_lock_nested(&JFS_IP(old_dir)->commit_mutex,
1154 				  COMMIT_MUTEX_SECOND_PARENT);
1155 
1156 	if (new_ip) {
1157 		mutex_lock_nested(&JFS_IP(new_ip)->commit_mutex,
1158 				  COMMIT_MUTEX_VICTIM);
1159 		/*
1160 		 * Change existing directory entry to new inode number
1161 		 */
1162 		ino = new_ip->i_ino;
1163 		rc = dtModify(tid, new_dir, &new_dname, &ino,
1164 			      old_ip->i_ino, JFS_RENAME);
1165 		if (rc)
1166 			goto out4;
1167 		drop_nlink(new_ip);
1168 		if (S_ISDIR(new_ip->i_mode)) {
1169 			drop_nlink(new_ip);
1170 			if (new_ip->i_nlink) {
1171 				mutex_unlock(&JFS_IP(new_ip)->commit_mutex);
1172 				if (old_dir != new_dir)
1173 					mutex_unlock(&JFS_IP(old_dir)->commit_mutex);
1174 				mutex_unlock(&JFS_IP(old_ip)->commit_mutex);
1175 				mutex_unlock(&JFS_IP(new_dir)->commit_mutex);
1176 				if (!S_ISDIR(old_ip->i_mode) && new_ip)
1177 					IWRITE_UNLOCK(new_ip);
1178 				jfs_error(new_ip->i_sb,
1179 					  "jfs_rename: new_ip->i_nlink != 0");
1180 				return -EIO;
1181 			}
1182 			tblk = tid_to_tblock(tid);
1183 			tblk->xflag |= COMMIT_DELETE;
1184 			tblk->u.ip = new_ip;
1185 		} else if (new_ip->i_nlink == 0) {
1186 			assert(!test_cflag(COMMIT_Nolink, new_ip));
1187 			/* free block resources */
1188 			if ((new_size = commitZeroLink(tid, new_ip)) < 0) {
1189 				txAbort(tid, 1);	/* Marks FS Dirty */
1190 				rc = new_size;
1191 				goto out4;
1192 			}
1193 			tblk = tid_to_tblock(tid);
1194 			tblk->xflag |= COMMIT_DELETE;
1195 			tblk->u.ip = new_ip;
1196 		} else {
1197 			new_ip->i_ctime = CURRENT_TIME;
1198 			mark_inode_dirty(new_ip);
1199 		}
1200 	} else {
1201 		/*
1202 		 * Add new directory entry
1203 		 */
1204 		rc = dtSearch(new_dir, &new_dname, &ino, &btstack,
1205 			      JFS_CREATE);
1206 		if (rc) {
1207 			jfs_err("jfs_rename didn't expect dtSearch to fail "
1208 				"w/rc = %d", rc);
1209 			goto out4;
1210 		}
1211 
1212 		ino = old_ip->i_ino;
1213 		rc = dtInsert(tid, new_dir, &new_dname, &ino, &btstack);
1214 		if (rc) {
1215 			if (rc == -EIO)
1216 				jfs_err("jfs_rename: dtInsert returned -EIO");
1217 			goto out4;
1218 		}
1219 		if (S_ISDIR(old_ip->i_mode))
1220 			inc_nlink(new_dir);
1221 	}
1222 	/*
1223 	 * Remove old directory entry
1224 	 */
1225 
1226 	ino = old_ip->i_ino;
1227 	rc = dtDelete(tid, old_dir, &old_dname, &ino, JFS_REMOVE);
1228 	if (rc) {
1229 		jfs_err("jfs_rename did not expect dtDelete to return rc = %d",
1230 			rc);
1231 		txAbort(tid, 1);	/* Marks Filesystem dirty */
1232 		goto out4;
1233 	}
1234 	if (S_ISDIR(old_ip->i_mode)) {
1235 		drop_nlink(old_dir);
1236 		if (old_dir != new_dir) {
1237 			/*
1238 			 * Change inode number of parent for moved directory
1239 			 */
1240 
1241 			JFS_IP(old_ip)->i_dtroot.header.idotdot =
1242 				cpu_to_le32(new_dir->i_ino);
1243 
1244 			/* Linelock header of dtree */
1245 			tlck = txLock(tid, old_ip,
1246 				    (struct metapage *) &JFS_IP(old_ip)->bxflag,
1247 				      tlckDTREE | tlckBTROOT | tlckRELINK);
1248 			dtlck = (struct dt_lock *) & tlck->lock;
1249 			ASSERT(dtlck->index == 0);
1250 			lv = & dtlck->lv[0];
1251 			lv->offset = 0;
1252 			lv->length = 1;
1253 			dtlck->index++;
1254 		}
1255 	}
1256 
1257 	/*
1258 	 * Update ctime on changed/moved inodes & mark dirty
1259 	 */
1260 	old_ip->i_ctime = CURRENT_TIME;
1261 	mark_inode_dirty(old_ip);
1262 
1263 	new_dir->i_ctime = new_dir->i_mtime = current_fs_time(new_dir->i_sb);
1264 	mark_inode_dirty(new_dir);
1265 
1266 	/* Build list of inodes modified by this transaction */
1267 	ipcount = 0;
1268 	iplist[ipcount++] = old_ip;
1269 	if (new_ip)
1270 		iplist[ipcount++] = new_ip;
1271 	iplist[ipcount++] = old_dir;
1272 
1273 	if (old_dir != new_dir) {
1274 		iplist[ipcount++] = new_dir;
1275 		old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
1276 		mark_inode_dirty(old_dir);
1277 	}
1278 
1279 	/*
1280 	 * Incomplete truncate of file data can
1281 	 * result in timing problems unless we synchronously commit the
1282 	 * transaction.
1283 	 */
1284 	if (new_size)
1285 		commit_flag = COMMIT_SYNC;
1286 	else
1287 		commit_flag = 0;
1288 
1289 	rc = txCommit(tid, ipcount, iplist, commit_flag);
1290 
1291       out4:
1292 	txEnd(tid);
1293 	if (new_ip)
1294 		mutex_unlock(&JFS_IP(new_ip)->commit_mutex);
1295 	if (old_dir != new_dir)
1296 		mutex_unlock(&JFS_IP(old_dir)->commit_mutex);
1297 	mutex_unlock(&JFS_IP(old_ip)->commit_mutex);
1298 	mutex_unlock(&JFS_IP(new_dir)->commit_mutex);
1299 
1300 	while (new_size && (rc == 0)) {
1301 		tid = txBegin(new_ip->i_sb, 0);
1302 		mutex_lock(&JFS_IP(new_ip)->commit_mutex);
1303 		new_size = xtTruncate_pmap(tid, new_ip, new_size);
1304 		if (new_size < 0) {
1305 			txAbort(tid, 1);
1306 			rc = new_size;
1307 		} else
1308 			rc = txCommit(tid, 1, &new_ip, COMMIT_SYNC);
1309 		txEnd(tid);
1310 		mutex_unlock(&JFS_IP(new_ip)->commit_mutex);
1311 	}
1312 	if (new_ip && (new_ip->i_nlink == 0))
1313 		set_cflag(COMMIT_Nolink, new_ip);
1314       out3:
1315 	free_UCSname(&new_dname);
1316       out2:
1317 	free_UCSname(&old_dname);
1318       out1:
1319 	if (new_ip && !S_ISDIR(new_ip->i_mode))
1320 		IWRITE_UNLOCK(new_ip);
1321 	/*
1322 	 * Truncating the directory index table is not guaranteed.  It
1323 	 * may need to be done iteratively
1324 	 */
1325 	if (test_cflag(COMMIT_Stale, old_dir)) {
1326 		if (old_dir->i_size > 1)
1327 			jfs_truncate_nolock(old_dir, 0);
1328 
1329 		clear_cflag(COMMIT_Stale, old_dir);
1330 	}
1331 
1332 	jfs_info("jfs_rename: returning %d", rc);
1333 	return rc;
1334 }
1335 
1336 
1337 /*
1338  * NAME:	jfs_mknod
1339  *
1340  * FUNCTION:	Create a special file (device)
1341  */
jfs_mknod(struct inode * dir,struct dentry * dentry,umode_t mode,dev_t rdev)1342 static int jfs_mknod(struct inode *dir, struct dentry *dentry,
1343 		umode_t mode, dev_t rdev)
1344 {
1345 	struct jfs_inode_info *jfs_ip;
1346 	struct btstack btstack;
1347 	struct component_name dname;
1348 	ino_t ino;
1349 	struct inode *ip;
1350 	struct inode *iplist[2];
1351 	int rc;
1352 	tid_t tid;
1353 	struct tblock *tblk;
1354 
1355 	if (!new_valid_dev(rdev))
1356 		return -EINVAL;
1357 
1358 	jfs_info("jfs_mknod: %s", dentry->d_name.name);
1359 
1360 	dquot_initialize(dir);
1361 
1362 	if ((rc = get_UCSname(&dname, dentry)))
1363 		goto out;
1364 
1365 	ip = ialloc(dir, mode);
1366 	if (IS_ERR(ip)) {
1367 		rc = PTR_ERR(ip);
1368 		goto out1;
1369 	}
1370 	jfs_ip = JFS_IP(ip);
1371 
1372 	tid = txBegin(dir->i_sb, 0);
1373 
1374 	mutex_lock_nested(&JFS_IP(dir)->commit_mutex, COMMIT_MUTEX_PARENT);
1375 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
1376 
1377 	rc = jfs_init_acl(tid, ip, dir);
1378 	if (rc)
1379 		goto out3;
1380 
1381 	rc = jfs_init_security(tid, ip, dir, &dentry->d_name);
1382 	if (rc) {
1383 		txAbort(tid, 0);
1384 		goto out3;
1385 	}
1386 
1387 	if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE))) {
1388 		txAbort(tid, 0);
1389 		goto out3;
1390 	}
1391 
1392 	tblk = tid_to_tblock(tid);
1393 	tblk->xflag |= COMMIT_CREATE;
1394 	tblk->ino = ip->i_ino;
1395 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
1396 
1397 	ino = ip->i_ino;
1398 	if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack))) {
1399 		txAbort(tid, 0);
1400 		goto out3;
1401 	}
1402 
1403 	ip->i_op = &jfs_file_inode_operations;
1404 	jfs_ip->dev = new_encode_dev(rdev);
1405 	init_special_inode(ip, ip->i_mode, rdev);
1406 
1407 	mark_inode_dirty(ip);
1408 
1409 	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
1410 
1411 	mark_inode_dirty(dir);
1412 
1413 	iplist[0] = dir;
1414 	iplist[1] = ip;
1415 	rc = txCommit(tid, 2, iplist, 0);
1416 
1417       out3:
1418 	txEnd(tid);
1419 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
1420 	mutex_unlock(&JFS_IP(dir)->commit_mutex);
1421 	if (rc) {
1422 		free_ea_wmap(ip);
1423 		clear_nlink(ip);
1424 		unlock_new_inode(ip);
1425 		iput(ip);
1426 	} else {
1427 		d_instantiate(dentry, ip);
1428 		unlock_new_inode(ip);
1429 	}
1430 
1431       out1:
1432 	free_UCSname(&dname);
1433 
1434       out:
1435 	jfs_info("jfs_mknod: returning %d", rc);
1436 	return rc;
1437 }
1438 
jfs_lookup(struct inode * dip,struct dentry * dentry,struct nameidata * nd)1439 static struct dentry *jfs_lookup(struct inode *dip, struct dentry *dentry, struct nameidata *nd)
1440 {
1441 	struct btstack btstack;
1442 	ino_t inum;
1443 	struct inode *ip;
1444 	struct component_name key;
1445 	int rc;
1446 
1447 	jfs_info("jfs_lookup: name = %s", dentry->d_name.name);
1448 
1449 	if ((rc = get_UCSname(&key, dentry)))
1450 		return ERR_PTR(rc);
1451 	rc = dtSearch(dip, &key, &inum, &btstack, JFS_LOOKUP);
1452 	free_UCSname(&key);
1453 	if (rc == -ENOENT) {
1454 		ip = NULL;
1455 	} else if (rc) {
1456 		jfs_err("jfs_lookup: dtSearch returned %d", rc);
1457 		ip = ERR_PTR(rc);
1458 	} else {
1459 		ip = jfs_iget(dip->i_sb, inum);
1460 		if (IS_ERR(ip))
1461 			jfs_err("jfs_lookup: iget failed on inum %d", (uint)inum);
1462 	}
1463 
1464 	return d_splice_alias(ip, dentry);
1465 }
1466 
jfs_nfs_get_inode(struct super_block * sb,u64 ino,u32 generation)1467 static struct inode *jfs_nfs_get_inode(struct super_block *sb,
1468 		u64 ino, u32 generation)
1469 {
1470 	struct inode *inode;
1471 
1472 	if (ino == 0)
1473 		return ERR_PTR(-ESTALE);
1474 	inode = jfs_iget(sb, ino);
1475 	if (IS_ERR(inode))
1476 		return ERR_CAST(inode);
1477 
1478 	if (generation && inode->i_generation != generation) {
1479 		iput(inode);
1480 		return ERR_PTR(-ESTALE);
1481 	}
1482 
1483 	return inode;
1484 }
1485 
jfs_fh_to_dentry(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)1486 struct dentry *jfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
1487 		int fh_len, int fh_type)
1488 {
1489 	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
1490 				    jfs_nfs_get_inode);
1491 }
1492 
jfs_fh_to_parent(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)1493 struct dentry *jfs_fh_to_parent(struct super_block *sb, struct fid *fid,
1494 		int fh_len, int fh_type)
1495 {
1496 	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
1497 				    jfs_nfs_get_inode);
1498 }
1499 
jfs_get_parent(struct dentry * dentry)1500 struct dentry *jfs_get_parent(struct dentry *dentry)
1501 {
1502 	unsigned long parent_ino;
1503 
1504 	parent_ino =
1505 		le32_to_cpu(JFS_IP(dentry->d_inode)->i_dtroot.header.idotdot);
1506 
1507 	return d_obtain_alias(jfs_iget(dentry->d_inode->i_sb, parent_ino));
1508 }
1509 
1510 const struct inode_operations jfs_dir_inode_operations = {
1511 	.create		= jfs_create,
1512 	.lookup		= jfs_lookup,
1513 	.link		= jfs_link,
1514 	.unlink		= jfs_unlink,
1515 	.symlink	= jfs_symlink,
1516 	.mkdir		= jfs_mkdir,
1517 	.rmdir		= jfs_rmdir,
1518 	.mknod		= jfs_mknod,
1519 	.rename		= jfs_rename,
1520 	.setxattr	= jfs_setxattr,
1521 	.getxattr	= jfs_getxattr,
1522 	.listxattr	= jfs_listxattr,
1523 	.removexattr	= jfs_removexattr,
1524 	.setattr	= jfs_setattr,
1525 #ifdef CONFIG_JFS_POSIX_ACL
1526 	.get_acl	= jfs_get_acl,
1527 #endif
1528 };
1529 
1530 const struct file_operations jfs_dir_operations = {
1531 	.read		= generic_read_dir,
1532 	.readdir	= jfs_readdir,
1533 	.fsync		= jfs_fsync,
1534 	.unlocked_ioctl = jfs_ioctl,
1535 #ifdef CONFIG_COMPAT
1536 	.compat_ioctl	= jfs_compat_ioctl,
1537 #endif
1538 	.llseek		= generic_file_llseek,
1539 };
1540 
jfs_ci_hash(const struct dentry * dir,const struct inode * inode,struct qstr * this)1541 static int jfs_ci_hash(const struct dentry *dir, const struct inode *inode,
1542 		struct qstr *this)
1543 {
1544 	unsigned long hash;
1545 	int i;
1546 
1547 	hash = init_name_hash();
1548 	for (i=0; i < this->len; i++)
1549 		hash = partial_name_hash(tolower(this->name[i]), hash);
1550 	this->hash = end_name_hash(hash);
1551 
1552 	return 0;
1553 }
1554 
jfs_ci_compare(const struct dentry * parent,const struct inode * pinode,const struct dentry * dentry,const struct inode * inode,unsigned int len,const char * str,const struct qstr * name)1555 static int jfs_ci_compare(const struct dentry *parent,
1556 		const struct inode *pinode,
1557 		const struct dentry *dentry, const struct inode *inode,
1558 		unsigned int len, const char *str, const struct qstr *name)
1559 {
1560 	int i, result = 1;
1561 
1562 	if (len != name->len)
1563 		goto out;
1564 	for (i=0; i < len; i++) {
1565 		if (tolower(str[i]) != tolower(name->name[i]))
1566 			goto out;
1567 	}
1568 	result = 0;
1569 out:
1570 	return result;
1571 }
1572 
jfs_ci_revalidate(struct dentry * dentry,struct nameidata * nd)1573 static int jfs_ci_revalidate(struct dentry *dentry, struct nameidata *nd)
1574 {
1575 	/*
1576 	 * This is not negative dentry. Always valid.
1577 	 *
1578 	 * Note, rename() to existing directory entry will have ->d_inode,
1579 	 * and will use existing name which isn't specified name by user.
1580 	 *
1581 	 * We may be able to drop this positive dentry here. But dropping
1582 	 * positive dentry isn't good idea. So it's unsupported like
1583 	 * rename("filename", "FILENAME") for now.
1584 	 */
1585 	if (dentry->d_inode)
1586 		return 1;
1587 
1588 	/*
1589 	 * This may be nfsd (or something), anyway, we can't see the
1590 	 * intent of this. So, since this can be for creation, drop it.
1591 	 */
1592 	if (!nd)
1593 		return 0;
1594 
1595 	/*
1596 	 * Drop the negative dentry, in order to make sure to use the
1597 	 * case sensitive name which is specified by user if this is
1598 	 * for creation.
1599 	 */
1600 	if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
1601 		return 0;
1602 	return 1;
1603 }
1604 
1605 const struct dentry_operations jfs_ci_dentry_operations =
1606 {
1607 	.d_hash = jfs_ci_hash,
1608 	.d_compare = jfs_ci_compare,
1609 	.d_revalidate = jfs_ci_revalidate,
1610 };
1611