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