blob: f4ad9e31ddc438a38896b19b68e051ab811336c2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/hpfs/namei.c
3 *
4 * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
5 *
6 * adding & removing files & directories
7 */
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +04008#include <linux/sched.h>
Alexey Dobriyan405f5572009-07-11 22:08:37 +04009#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include "hpfs_fn.h"
11
12static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
13{
Al Viro7e7742e2010-01-31 17:09:29 -050014 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 unsigned len = dentry->d_name.len;
16 struct quad_buffer_head qbh0;
17 struct buffer_head *bh;
18 struct hpfs_dirent *de;
19 struct fnode *fnode;
20 struct dnode *dnode;
21 struct inode *result;
22 fnode_secno fno;
23 dnode_secno dno;
24 int r;
25 struct hpfs_dirent dee;
26 int err;
Al Viro7e7742e2010-01-31 17:09:29 -050027 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 lock_kernel();
29 err = -ENOSPC;
30 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
31 if (!fnode)
32 goto bail;
33 dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1);
34 if (!dnode)
35 goto bail1;
36 memset(&dee, 0, sizeof dee);
37 dee.directory = 1;
38 if (!(mode & 0222)) dee.read_only = 1;
39 /*dee.archive = 0;*/
40 dee.hidden = name[0] == '.';
41 dee.fnode = fno;
42 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
43 result = new_inode(dir->i_sb);
44 if (!result)
45 goto bail2;
46 hpfs_init_inode(result);
47 result->i_ino = fno;
48 hpfs_i(result)->i_parent_dir = dir->i_ino;
49 hpfs_i(result)->i_dno = dno;
50 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
51 result->i_ctime.tv_nsec = 0;
52 result->i_mtime.tv_nsec = 0;
53 result->i_atime.tv_nsec = 0;
54 hpfs_i(result)->i_ea_size = 0;
55 result->i_mode |= S_IFDIR;
56 result->i_op = &hpfs_dir_iops;
57 result->i_fop = &hpfs_dir_ops;
58 result->i_blocks = 4;
59 result->i_size = 2048;
60 result->i_nlink = 2;
61 if (dee.read_only)
62 result->i_mode &= ~0222;
63
Ingo Molnar7bf6d782006-03-23 03:00:42 -080064 mutex_lock(&hpfs_i(dir)->i_mutex);
Al Viro7e7742e2010-01-31 17:09:29 -050065 r = hpfs_add_dirent(dir, name, len, &dee, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 if (r == 1)
67 goto bail3;
68 if (r == -1) {
69 err = -EEXIST;
70 goto bail3;
71 }
72 fnode->len = len;
73 memcpy(fnode->name, name, len > 15 ? 15 : len);
74 fnode->up = dir->i_ino;
75 fnode->dirflag = 1;
76 fnode->btree.n_free_nodes = 7;
77 fnode->btree.n_used_nodes = 1;
78 fnode->btree.first_free = 0x14;
79 fnode->u.external[0].disk_secno = dno;
80 fnode->u.external[0].file_secno = -1;
81 dnode->root_dnode = 1;
82 dnode->up = fno;
83 de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
84 de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, get_seconds());
85 if (!(mode & 0222)) de->read_only = 1;
86 de->first = de->directory = 1;
87 /*de->hidden = de->system = 0;*/
88 de->fnode = fno;
89 mark_buffer_dirty(bh);
90 brelse(bh);
91 hpfs_mark_4buffers_dirty(&qbh0);
92 hpfs_brelse4(&qbh0);
Dave Hansend8c76e62006-09-30 23:29:04 -070093 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 insert_inode_hash(result);
95
David Howellsde395b82008-11-14 10:38:55 +110096 if (result->i_uid != current_fsuid() ||
97 result->i_gid != current_fsgid() ||
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 result->i_mode != (mode | S_IFDIR)) {
David Howellsde395b82008-11-14 10:38:55 +110099 result->i_uid = current_fsuid();
100 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 result->i_mode = mode | S_IFDIR;
102 hpfs_write_inode_nolock(result);
103 }
104 d_instantiate(dentry, result);
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800105 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 unlock_kernel();
107 return 0;
108bail3:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800109 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 iput(result);
111bail2:
112 hpfs_brelse4(&qbh0);
113 hpfs_free_dnode(dir->i_sb, dno);
114bail1:
115 brelse(bh);
116 hpfs_free_sectors(dir->i_sb, fno, 1);
117bail:
118 unlock_kernel();
119 return err;
120}
121
122static int hpfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
123{
Al Viro7e7742e2010-01-31 17:09:29 -0500124 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 unsigned len = dentry->d_name.len;
126 struct inode *result = NULL;
127 struct buffer_head *bh;
128 struct fnode *fnode;
129 fnode_secno fno;
130 int r;
131 struct hpfs_dirent dee;
132 int err;
Al Viro7e7742e2010-01-31 17:09:29 -0500133 if ((err = hpfs_chk_name(name, &len)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 return err==-ENOENT ? -EINVAL : err;
135 lock_kernel();
136 err = -ENOSPC;
137 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
138 if (!fnode)
139 goto bail;
140 memset(&dee, 0, sizeof dee);
141 if (!(mode & 0222)) dee.read_only = 1;
142 dee.archive = 1;
143 dee.hidden = name[0] == '.';
144 dee.fnode = fno;
145 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
146
147 result = new_inode(dir->i_sb);
148 if (!result)
149 goto bail1;
150
151 hpfs_init_inode(result);
152 result->i_ino = fno;
153 result->i_mode |= S_IFREG;
154 result->i_mode &= ~0111;
155 result->i_op = &hpfs_file_iops;
156 result->i_fop = &hpfs_file_ops;
157 result->i_nlink = 1;
Al Viro7e7742e2010-01-31 17:09:29 -0500158 hpfs_decide_conv(result, name, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 hpfs_i(result)->i_parent_dir = dir->i_ino;
160 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
161 result->i_ctime.tv_nsec = 0;
162 result->i_mtime.tv_nsec = 0;
163 result->i_atime.tv_nsec = 0;
164 hpfs_i(result)->i_ea_size = 0;
165 if (dee.read_only)
166 result->i_mode &= ~0222;
167 result->i_blocks = 1;
168 result->i_size = 0;
169 result->i_data.a_ops = &hpfs_aops;
170 hpfs_i(result)->mmu_private = 0;
171
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800172 mutex_lock(&hpfs_i(dir)->i_mutex);
Al Viro7e7742e2010-01-31 17:09:29 -0500173 r = hpfs_add_dirent(dir, name, len, &dee, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 if (r == 1)
175 goto bail2;
176 if (r == -1) {
177 err = -EEXIST;
178 goto bail2;
179 }
180 fnode->len = len;
181 memcpy(fnode->name, name, len > 15 ? 15 : len);
182 fnode->up = dir->i_ino;
183 mark_buffer_dirty(bh);
184 brelse(bh);
185
186 insert_inode_hash(result);
187
David Howellsde395b82008-11-14 10:38:55 +1100188 if (result->i_uid != current_fsuid() ||
189 result->i_gid != current_fsgid() ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 result->i_mode != (mode | S_IFREG)) {
David Howellsde395b82008-11-14 10:38:55 +1100191 result->i_uid = current_fsuid();
192 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 result->i_mode = mode | S_IFREG;
194 hpfs_write_inode_nolock(result);
195 }
196 d_instantiate(dentry, result);
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800197 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 unlock_kernel();
199 return 0;
200
201bail2:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800202 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 iput(result);
204bail1:
205 brelse(bh);
206 hpfs_free_sectors(dir->i_sb, fno, 1);
207bail:
208 unlock_kernel();
209 return err;
210}
211
212static int hpfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
213{
Al Viro7e7742e2010-01-31 17:09:29 -0500214 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 unsigned len = dentry->d_name.len;
216 struct buffer_head *bh;
217 struct fnode *fnode;
218 fnode_secno fno;
219 int r;
220 struct hpfs_dirent dee;
221 struct inode *result = NULL;
222 int err;
Al Viro7e7742e2010-01-31 17:09:29 -0500223 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 if (hpfs_sb(dir->i_sb)->sb_eas < 2) return -EPERM;
225 if (!new_valid_dev(rdev))
226 return -EINVAL;
227 lock_kernel();
228 err = -ENOSPC;
229 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
230 if (!fnode)
231 goto bail;
232 memset(&dee, 0, sizeof dee);
233 if (!(mode & 0222)) dee.read_only = 1;
234 dee.archive = 1;
235 dee.hidden = name[0] == '.';
236 dee.fnode = fno;
237 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
238
239 result = new_inode(dir->i_sb);
240 if (!result)
241 goto bail1;
242
243 hpfs_init_inode(result);
244 result->i_ino = fno;
245 hpfs_i(result)->i_parent_dir = dir->i_ino;
246 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
247 result->i_ctime.tv_nsec = 0;
248 result->i_mtime.tv_nsec = 0;
249 result->i_atime.tv_nsec = 0;
250 hpfs_i(result)->i_ea_size = 0;
David Howellsde395b82008-11-14 10:38:55 +1100251 result->i_uid = current_fsuid();
252 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 result->i_nlink = 1;
254 result->i_size = 0;
255 result->i_blocks = 1;
256 init_special_inode(result, mode, rdev);
257
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800258 mutex_lock(&hpfs_i(dir)->i_mutex);
Al Viro7e7742e2010-01-31 17:09:29 -0500259 r = hpfs_add_dirent(dir, name, len, &dee, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 if (r == 1)
261 goto bail2;
262 if (r == -1) {
263 err = -EEXIST;
264 goto bail2;
265 }
266 fnode->len = len;
267 memcpy(fnode->name, name, len > 15 ? 15 : len);
268 fnode->up = dir->i_ino;
269 mark_buffer_dirty(bh);
270
271 insert_inode_hash(result);
272
273 hpfs_write_inode_nolock(result);
274 d_instantiate(dentry, result);
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800275 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 brelse(bh);
277 unlock_kernel();
278 return 0;
279bail2:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800280 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 iput(result);
282bail1:
283 brelse(bh);
284 hpfs_free_sectors(dir->i_sb, fno, 1);
285bail:
286 unlock_kernel();
287 return err;
288}
289
290static int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink)
291{
Al Viro7e7742e2010-01-31 17:09:29 -0500292 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 unsigned len = dentry->d_name.len;
294 struct buffer_head *bh;
295 struct fnode *fnode;
296 fnode_secno fno;
297 int r;
298 struct hpfs_dirent dee;
299 struct inode *result;
300 int err;
Al Viro7e7742e2010-01-31 17:09:29 -0500301 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 lock_kernel();
303 if (hpfs_sb(dir->i_sb)->sb_eas < 2) {
304 unlock_kernel();
305 return -EPERM;
306 }
307 err = -ENOSPC;
308 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
309 if (!fnode)
310 goto bail;
311 memset(&dee, 0, sizeof dee);
312 dee.archive = 1;
313 dee.hidden = name[0] == '.';
314 dee.fnode = fno;
315 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
316
317 result = new_inode(dir->i_sb);
318 if (!result)
319 goto bail1;
320 result->i_ino = fno;
321 hpfs_init_inode(result);
322 hpfs_i(result)->i_parent_dir = dir->i_ino;
323 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
324 result->i_ctime.tv_nsec = 0;
325 result->i_mtime.tv_nsec = 0;
326 result->i_atime.tv_nsec = 0;
327 hpfs_i(result)->i_ea_size = 0;
328 result->i_mode = S_IFLNK | 0777;
David Howellsde395b82008-11-14 10:38:55 +1100329 result->i_uid = current_fsuid();
330 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 result->i_blocks = 1;
332 result->i_nlink = 1;
333 result->i_size = strlen(symlink);
334 result->i_op = &page_symlink_inode_operations;
335 result->i_data.a_ops = &hpfs_symlink_aops;
336
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800337 mutex_lock(&hpfs_i(dir)->i_mutex);
Al Viro7e7742e2010-01-31 17:09:29 -0500338 r = hpfs_add_dirent(dir, name, len, &dee, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 if (r == 1)
340 goto bail2;
341 if (r == -1) {
342 err = -EEXIST;
343 goto bail2;
344 }
345 fnode->len = len;
346 memcpy(fnode->name, name, len > 15 ? 15 : len);
347 fnode->up = dir->i_ino;
Al Viro7e7742e2010-01-31 17:09:29 -0500348 hpfs_set_ea(result, fnode, "SYMLINK", symlink, strlen(symlink));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 mark_buffer_dirty(bh);
350 brelse(bh);
351
352 insert_inode_hash(result);
353
354 hpfs_write_inode_nolock(result);
355 d_instantiate(dentry, result);
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800356 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 unlock_kernel();
358 return 0;
359bail2:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800360 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 iput(result);
362bail1:
363 brelse(bh);
364 hpfs_free_sectors(dir->i_sb, fno, 1);
365bail:
366 unlock_kernel();
367 return err;
368}
369
370static int hpfs_unlink(struct inode *dir, struct dentry *dentry)
371{
Al Viro7e7742e2010-01-31 17:09:29 -0500372 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 unsigned len = dentry->d_name.len;
374 struct quad_buffer_head qbh;
375 struct hpfs_dirent *de;
376 struct inode *inode = dentry->d_inode;
377 dnode_secno dno;
378 fnode_secno fno;
379 int r;
380 int rep = 0;
381 int err;
382
383 lock_kernel();
Al Viro7e7742e2010-01-31 17:09:29 -0500384 hpfs_adjust_length(name, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385again:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800386 mutex_lock(&hpfs_i(inode)->i_parent_mutex);
387 mutex_lock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 err = -ENOENT;
Al Viro7e7742e2010-01-31 17:09:29 -0500389 de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 if (!de)
391 goto out;
392
393 err = -EPERM;
394 if (de->first)
395 goto out1;
396
397 err = -EISDIR;
398 if (de->directory)
399 goto out1;
400
401 fno = de->fnode;
402 r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
403 switch (r) {
404 case 1:
405 hpfs_error(dir->i_sb, "there was error when removing dirent");
406 err = -EFSERROR;
407 break;
408 case 2: /* no space for deleting, try to truncate file */
409
410 err = -ENOSPC;
411 if (rep++)
412 break;
413
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800414 mutex_unlock(&hpfs_i(dir)->i_mutex);
415 mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
Al Viroe21e7092010-02-01 11:05:16 -0500416 dentry_unhash(dentry);
417 if (!d_unhashed(dentry)) {
418 dput(dentry);
419 unlock_kernel();
420 return -ENOSPC;
421 }
Nick Pigginb74c79e2011-01-07 17:49:58 +1100422 if (generic_permission(inode, MAY_WRITE, 0, NULL) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 !S_ISREG(inode->i_mode) ||
424 get_write_access(inode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 d_rehash(dentry);
Al Viroe21e7092010-02-01 11:05:16 -0500426 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 } else {
428 struct iattr newattrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 /*printk("HPFS: truncating file before delete.\n");*/
430 newattrs.ia_size = 0;
431 newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
432 err = notify_change(dentry, &newattrs);
433 put_write_access(inode);
Al Viroe21e7092010-02-01 11:05:16 -0500434 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 if (!err)
436 goto again;
437 }
438 unlock_kernel();
439 return -ENOSPC;
440 default:
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700441 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 err = 0;
443 }
444 goto out;
445
446out1:
447 hpfs_brelse4(&qbh);
448out:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800449 mutex_unlock(&hpfs_i(dir)->i_mutex);
450 mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 unlock_kernel();
452 return err;
453}
454
455static int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
456{
Al Viro7e7742e2010-01-31 17:09:29 -0500457 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 unsigned len = dentry->d_name.len;
459 struct quad_buffer_head qbh;
460 struct hpfs_dirent *de;
461 struct inode *inode = dentry->d_inode;
462 dnode_secno dno;
463 fnode_secno fno;
464 int n_items = 0;
465 int err;
466 int r;
467
Al Viro7e7742e2010-01-31 17:09:29 -0500468 hpfs_adjust_length(name, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 lock_kernel();
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800470 mutex_lock(&hpfs_i(inode)->i_parent_mutex);
471 mutex_lock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 err = -ENOENT;
Al Viro7e7742e2010-01-31 17:09:29 -0500473 de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 if (!de)
475 goto out;
476
477 err = -EPERM;
478 if (de->first)
479 goto out1;
480
481 err = -ENOTDIR;
482 if (!de->directory)
483 goto out1;
484
485 hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items);
486 err = -ENOTEMPTY;
487 if (n_items)
488 goto out1;
489
490 fno = de->fnode;
491 r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
492 switch (r) {
493 case 1:
494 hpfs_error(dir->i_sb, "there was error when removing dirent");
495 err = -EFSERROR;
496 break;
497 case 2:
498 err = -ENOSPC;
499 break;
500 default:
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700501 drop_nlink(dir);
Dave Hansence71ec32006-09-30 23:29:06 -0700502 clear_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 err = 0;
504 }
505 goto out;
506out1:
507 hpfs_brelse4(&qbh);
508out:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800509 mutex_unlock(&hpfs_i(dir)->i_mutex);
510 mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 unlock_kernel();
512 return err;
513}
514
515static int hpfs_symlink_readpage(struct file *file, struct page *page)
516{
517 char *link = kmap(page);
518 struct inode *i = page->mapping->host;
519 struct fnode *fnode;
520 struct buffer_head *bh;
521 int err;
522
523 err = -EIO;
524 lock_kernel();
525 if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh)))
526 goto fail;
527 err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);
528 brelse(bh);
529 if (err)
530 goto fail;
531 unlock_kernel();
532 SetPageUptodate(page);
533 kunmap(page);
534 unlock_page(page);
535 return 0;
536
537fail:
538 unlock_kernel();
539 SetPageError(page);
540 kunmap(page);
541 unlock_page(page);
542 return err;
543}
544
Christoph Hellwigf5e54d62006-06-28 04:26:44 -0700545const struct address_space_operations hpfs_symlink_aops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 .readpage = hpfs_symlink_readpage
547};
548
549static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
550 struct inode *new_dir, struct dentry *new_dentry)
551{
Al Viro7e7742e2010-01-31 17:09:29 -0500552 const unsigned char *old_name = old_dentry->d_name.name;
553 unsigned old_len = old_dentry->d_name.len;
554 const unsigned char *new_name = new_dentry->d_name.name;
555 unsigned new_len = new_dentry->d_name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 struct inode *i = old_dentry->d_inode;
557 struct inode *new_inode = new_dentry->d_inode;
558 struct quad_buffer_head qbh, qbh1;
559 struct hpfs_dirent *dep, *nde;
560 struct hpfs_dirent de;
561 dnode_secno dno;
562 int r;
563 struct buffer_head *bh;
564 struct fnode *fnode;
565 int err;
Al Viro7e7742e2010-01-31 17:09:29 -0500566 if ((err = hpfs_chk_name(new_name, &new_len))) return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 err = 0;
Al Viro7e7742e2010-01-31 17:09:29 -0500568 hpfs_adjust_length(old_name, &old_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 lock_kernel();
571 /* order doesn't matter, due to VFS exclusion */
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800572 mutex_lock(&hpfs_i(i)->i_parent_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 if (new_inode)
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800574 mutex_lock(&hpfs_i(new_inode)->i_parent_mutex);
575 mutex_lock(&hpfs_i(old_dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 if (new_dir != old_dir)
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800577 mutex_lock(&hpfs_i(new_dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
579 /* Erm? Moving over the empty non-busy directory is perfectly legal */
580 if (new_inode && S_ISDIR(new_inode->i_mode)) {
581 err = -EINVAL;
582 goto end1;
583 }
584
Al Viro7e7742e2010-01-31 17:09:29 -0500585 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");
587 err = -ENOENT;
588 goto end1;
589 }
590 copy_de(&de, dep);
591 de.hidden = new_name[0] == '.';
592
593 if (new_inode) {
594 int r;
595 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {
Al Viro7e7742e2010-01-31 17:09:29 -0500596 if ((nde = map_dirent(new_dir, hpfs_i(new_dir)->i_dno, new_name, new_len, NULL, &qbh1))) {
Dave Hansence71ec32006-09-30 23:29:06 -0700597 clear_nlink(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 copy_de(nde, &de);
599 memcpy(nde->name, new_name, new_len);
600 hpfs_mark_4buffers_dirty(&qbh1);
601 hpfs_brelse4(&qbh1);
602 goto end;
603 }
604 hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");
605 err = -EFSERROR;
606 goto end1;
607 }
608 err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
609 goto end1;
610 }
611
612 if (new_dir == old_dir) hpfs_brelse4(&qbh);
613
614 hpfs_lock_creation(i->i_sb);
615 if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {
616 hpfs_unlock_creation(i->i_sb);
617 if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
618 err = r == 1 ? -ENOSPC : -EFSERROR;
619 if (new_dir != old_dir) hpfs_brelse4(&qbh);
620 goto end1;
621 }
622
623 if (new_dir == old_dir)
Al Viro7e7742e2010-01-31 17:09:29 -0500624 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 hpfs_unlock_creation(i->i_sb);
626 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
627 err = -ENOENT;
628 goto end1;
629 }
630
631 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
632 hpfs_unlock_creation(i->i_sb);
633 hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
634 err = r == 2 ? -ENOSPC : -EFSERROR;
635 goto end1;
636 }
637 hpfs_unlock_creation(i->i_sb);
638
639 end:
640 hpfs_i(i)->i_parent_dir = new_dir->i_ino;
641 if (S_ISDIR(i->i_mode)) {
Dave Hansend8c76e62006-09-30 23:29:04 -0700642 inc_nlink(new_dir);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700643 drop_nlink(old_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 }
645 if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
646 fnode->up = new_dir->i_ino;
647 fnode->len = new_len;
648 memcpy(fnode->name, new_name, new_len>15?15:new_len);
649 if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
650 mark_buffer_dirty(bh);
651 brelse(bh);
652 }
653 hpfs_i(i)->i_conv = hpfs_sb(i->i_sb)->sb_conv;
Al Viro7e7742e2010-01-31 17:09:29 -0500654 hpfs_decide_conv(i, new_name, new_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655end1:
656 if (old_dir != new_dir)
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800657 mutex_unlock(&hpfs_i(new_dir)->i_mutex);
658 mutex_unlock(&hpfs_i(old_dir)->i_mutex);
659 mutex_unlock(&hpfs_i(i)->i_parent_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 if (new_inode)
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800661 mutex_unlock(&hpfs_i(new_inode)->i_parent_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 unlock_kernel();
663 return err;
664}
665
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -0800666const struct inode_operations hpfs_dir_iops =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667{
668 .create = hpfs_create,
669 .lookup = hpfs_lookup,
670 .unlink = hpfs_unlink,
671 .symlink = hpfs_symlink,
672 .mkdir = hpfs_mkdir,
673 .rmdir = hpfs_rmdir,
674 .mknod = hpfs_mknod,
675 .rename = hpfs_rename,
Christoph Hellwigca30bc92008-08-11 00:27:59 +0200676 .setattr = hpfs_setattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677};