1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * linux/fs/hpfs/namei.c |
4 | * |
5 | * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999 |
6 | * |
7 | * adding & removing files & directories |
8 | */ |
9 | #include <linux/sched.h> |
10 | #include "hpfs_fn.h" |
11 | |
12 | static void hpfs_update_directory_times(struct inode *dir) |
13 | { |
14 | time64_t t = local_to_gmt(s: dir->i_sb, t: local_get_seconds(s: dir->i_sb)); |
15 | if (t == inode_get_mtime_sec(inode: dir) && |
16 | t == inode_get_ctime_sec(inode: dir)) |
17 | return; |
18 | inode_set_mtime_to_ts(inode: dir, ts: inode_set_ctime(inode: dir, sec: t, nsec: 0)); |
19 | hpfs_write_inode_nolock(dir); |
20 | } |
21 | |
22 | static int hpfs_mkdir(struct mnt_idmap *idmap, struct inode *dir, |
23 | struct dentry *dentry, umode_t mode) |
24 | { |
25 | const unsigned char *name = dentry->d_name.name; |
26 | unsigned len = dentry->d_name.len; |
27 | struct quad_buffer_head qbh0; |
28 | struct buffer_head *bh; |
29 | struct hpfs_dirent *de; |
30 | struct fnode *fnode; |
31 | struct dnode *dnode; |
32 | struct inode *result; |
33 | fnode_secno fno; |
34 | dnode_secno dno; |
35 | int r; |
36 | struct hpfs_dirent dee; |
37 | int err; |
38 | if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err; |
39 | hpfs_lock(s: dir->i_sb); |
40 | err = -ENOSPC; |
41 | fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(inode: dir)->i_dno, &fno, &bh); |
42 | if (!fnode) |
43 | goto bail; |
44 | dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0); |
45 | if (!dnode) |
46 | goto bail1; |
47 | memset(&dee, 0, sizeof dee); |
48 | dee.directory = 1; |
49 | if (!(mode & 0222)) dee.read_only = 1; |
50 | /*dee.archive = 0;*/ |
51 | dee.hidden = name[0] == '.'; |
52 | dee.fnode = cpu_to_le32(fno); |
53 | dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb)); |
54 | result = new_inode(sb: dir->i_sb); |
55 | if (!result) |
56 | goto bail2; |
57 | hpfs_init_inode(result); |
58 | result->i_ino = fno; |
59 | hpfs_i(inode: result)->i_parent_dir = dir->i_ino; |
60 | hpfs_i(inode: result)->i_dno = dno; |
61 | inode_set_mtime_to_ts(inode: result, |
62 | ts: inode_set_atime_to_ts(inode: result, ts: inode_set_ctime(inode: result, sec: local_to_gmt(s: dir->i_sb, le32_to_cpu(dee.creation_date)), nsec: 0))); |
63 | hpfs_i(inode: result)->i_ea_size = 0; |
64 | result->i_mode |= S_IFDIR; |
65 | result->i_op = &hpfs_dir_iops; |
66 | result->i_fop = &hpfs_dir_ops; |
67 | result->i_blocks = 4; |
68 | result->i_size = 2048; |
69 | set_nlink(inode: result, nlink: 2); |
70 | if (dee.read_only) |
71 | result->i_mode &= ~0222; |
72 | |
73 | r = hpfs_add_dirent(dir, name, len, &dee); |
74 | if (r == 1) |
75 | goto bail3; |
76 | if (r == -1) { |
77 | err = -EEXIST; |
78 | goto bail3; |
79 | } |
80 | fnode->len = len; |
81 | memcpy(fnode->name, name, len > 15 ? 15 : len); |
82 | fnode->up = cpu_to_le32(dir->i_ino); |
83 | fnode->flags |= FNODE_dir; |
84 | fnode->btree.n_free_nodes = 7; |
85 | fnode->btree.n_used_nodes = 1; |
86 | fnode->btree.first_free = cpu_to_le16(0x14); |
87 | fnode->u.external[0].disk_secno = cpu_to_le32(dno); |
88 | fnode->u.external[0].file_secno = cpu_to_le32(-1); |
89 | dnode->root_dnode = 1; |
90 | dnode->up = cpu_to_le32(fno); |
91 | de = hpfs_add_de(dir->i_sb, dnode, "\001\001" , 2, 0); |
92 | de->creation_date = de->write_date = de->read_date = cpu_to_le32(local_get_seconds(dir->i_sb)); |
93 | if (!(mode & 0222)) de->read_only = 1; |
94 | de->first = de->directory = 1; |
95 | /*de->hidden = de->system = 0;*/ |
96 | de->fnode = cpu_to_le32(fno); |
97 | mark_buffer_dirty(bh); |
98 | brelse(bh); |
99 | hpfs_mark_4buffers_dirty(&qbh0); |
100 | hpfs_brelse4(&qbh0); |
101 | inc_nlink(inode: dir); |
102 | insert_inode_hash(inode: result); |
103 | |
104 | if (!uid_eq(left: result->i_uid, current_fsuid()) || |
105 | !gid_eq(left: result->i_gid, current_fsgid()) || |
106 | result->i_mode != (mode | S_IFDIR)) { |
107 | result->i_uid = current_fsuid(); |
108 | result->i_gid = current_fsgid(); |
109 | result->i_mode = mode | S_IFDIR; |
110 | hpfs_write_inode_nolock(result); |
111 | } |
112 | hpfs_update_directory_times(dir); |
113 | d_instantiate(dentry, result); |
114 | hpfs_unlock(s: dir->i_sb); |
115 | return 0; |
116 | bail3: |
117 | iput(result); |
118 | bail2: |
119 | hpfs_brelse4(&qbh0); |
120 | hpfs_free_dnode(dir->i_sb, dno); |
121 | bail1: |
122 | brelse(bh); |
123 | hpfs_free_sectors(dir->i_sb, fno, 1); |
124 | bail: |
125 | hpfs_unlock(s: dir->i_sb); |
126 | return err; |
127 | } |
128 | |
129 | static int hpfs_create(struct mnt_idmap *idmap, struct inode *dir, |
130 | struct dentry *dentry, umode_t mode, bool excl) |
131 | { |
132 | const unsigned char *name = dentry->d_name.name; |
133 | unsigned len = dentry->d_name.len; |
134 | struct inode *result = NULL; |
135 | struct buffer_head *bh; |
136 | struct fnode *fnode; |
137 | fnode_secno fno; |
138 | int r; |
139 | struct hpfs_dirent dee; |
140 | int err; |
141 | if ((err = hpfs_chk_name(name, &len))) |
142 | return err==-ENOENT ? -EINVAL : err; |
143 | hpfs_lock(s: dir->i_sb); |
144 | err = -ENOSPC; |
145 | fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(inode: dir)->i_dno, &fno, &bh); |
146 | if (!fnode) |
147 | goto bail; |
148 | memset(&dee, 0, sizeof dee); |
149 | if (!(mode & 0222)) dee.read_only = 1; |
150 | dee.archive = 1; |
151 | dee.hidden = name[0] == '.'; |
152 | dee.fnode = cpu_to_le32(fno); |
153 | dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb)); |
154 | |
155 | result = new_inode(sb: dir->i_sb); |
156 | if (!result) |
157 | goto bail1; |
158 | |
159 | hpfs_init_inode(result); |
160 | result->i_ino = fno; |
161 | result->i_mode |= S_IFREG; |
162 | result->i_mode &= ~0111; |
163 | result->i_op = &hpfs_file_iops; |
164 | result->i_fop = &hpfs_file_ops; |
165 | set_nlink(inode: result, nlink: 1); |
166 | hpfs_i(inode: result)->i_parent_dir = dir->i_ino; |
167 | inode_set_mtime_to_ts(inode: result, |
168 | ts: inode_set_atime_to_ts(inode: result, ts: inode_set_ctime(inode: result, sec: local_to_gmt(s: dir->i_sb, le32_to_cpu(dee.creation_date)), nsec: 0))); |
169 | hpfs_i(inode: result)->i_ea_size = 0; |
170 | if (dee.read_only) |
171 | result->i_mode &= ~0222; |
172 | result->i_blocks = 1; |
173 | result->i_size = 0; |
174 | result->i_data.a_ops = &hpfs_aops; |
175 | hpfs_i(inode: result)->mmu_private = 0; |
176 | |
177 | r = hpfs_add_dirent(dir, name, len, &dee); |
178 | if (r == 1) |
179 | goto bail2; |
180 | if (r == -1) { |
181 | err = -EEXIST; |
182 | goto bail2; |
183 | } |
184 | fnode->len = len; |
185 | memcpy(fnode->name, name, len > 15 ? 15 : len); |
186 | fnode->up = cpu_to_le32(dir->i_ino); |
187 | mark_buffer_dirty(bh); |
188 | brelse(bh); |
189 | |
190 | insert_inode_hash(inode: result); |
191 | |
192 | if (!uid_eq(left: result->i_uid, current_fsuid()) || |
193 | !gid_eq(left: result->i_gid, current_fsgid()) || |
194 | result->i_mode != (mode | S_IFREG)) { |
195 | result->i_uid = current_fsuid(); |
196 | result->i_gid = current_fsgid(); |
197 | result->i_mode = mode | S_IFREG; |
198 | hpfs_write_inode_nolock(result); |
199 | } |
200 | hpfs_update_directory_times(dir); |
201 | d_instantiate(dentry, result); |
202 | hpfs_unlock(s: dir->i_sb); |
203 | return 0; |
204 | |
205 | bail2: |
206 | iput(result); |
207 | bail1: |
208 | brelse(bh); |
209 | hpfs_free_sectors(dir->i_sb, fno, 1); |
210 | bail: |
211 | hpfs_unlock(s: dir->i_sb); |
212 | return err; |
213 | } |
214 | |
215 | static int hpfs_mknod(struct mnt_idmap *idmap, struct inode *dir, |
216 | struct dentry *dentry, umode_t mode, dev_t rdev) |
217 | { |
218 | const unsigned char *name = dentry->d_name.name; |
219 | unsigned len = dentry->d_name.len; |
220 | struct buffer_head *bh; |
221 | struct fnode *fnode; |
222 | fnode_secno fno; |
223 | int r; |
224 | struct hpfs_dirent dee; |
225 | struct inode *result = NULL; |
226 | int err; |
227 | if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err; |
228 | if (hpfs_sb(sb: dir->i_sb)->sb_eas < 2) return -EPERM; |
229 | hpfs_lock(s: dir->i_sb); |
230 | err = -ENOSPC; |
231 | fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(inode: dir)->i_dno, &fno, &bh); |
232 | if (!fnode) |
233 | goto bail; |
234 | memset(&dee, 0, sizeof dee); |
235 | if (!(mode & 0222)) dee.read_only = 1; |
236 | dee.archive = 1; |
237 | dee.hidden = name[0] == '.'; |
238 | dee.fnode = cpu_to_le32(fno); |
239 | dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb)); |
240 | |
241 | result = new_inode(sb: dir->i_sb); |
242 | if (!result) |
243 | goto bail1; |
244 | |
245 | hpfs_init_inode(result); |
246 | result->i_ino = fno; |
247 | hpfs_i(inode: result)->i_parent_dir = dir->i_ino; |
248 | inode_set_mtime_to_ts(inode: result, |
249 | ts: inode_set_atime_to_ts(inode: result, ts: inode_set_ctime(inode: result, sec: local_to_gmt(s: dir->i_sb, le32_to_cpu(dee.creation_date)), nsec: 0))); |
250 | hpfs_i(inode: result)->i_ea_size = 0; |
251 | result->i_uid = current_fsuid(); |
252 | result->i_gid = current_fsgid(); |
253 | set_nlink(inode: result, nlink: 1); |
254 | result->i_size = 0; |
255 | result->i_blocks = 1; |
256 | init_special_inode(result, mode, rdev); |
257 | |
258 | r = hpfs_add_dirent(dir, name, len, &dee); |
259 | if (r == 1) |
260 | goto bail2; |
261 | if (r == -1) { |
262 | err = -EEXIST; |
263 | goto bail2; |
264 | } |
265 | fnode->len = len; |
266 | memcpy(fnode->name, name, len > 15 ? 15 : len); |
267 | fnode->up = cpu_to_le32(dir->i_ino); |
268 | mark_buffer_dirty(bh); |
269 | |
270 | insert_inode_hash(inode: result); |
271 | |
272 | hpfs_write_inode_nolock(result); |
273 | hpfs_update_directory_times(dir); |
274 | d_instantiate(dentry, result); |
275 | brelse(bh); |
276 | hpfs_unlock(s: dir->i_sb); |
277 | return 0; |
278 | bail2: |
279 | iput(result); |
280 | bail1: |
281 | brelse(bh); |
282 | hpfs_free_sectors(dir->i_sb, fno, 1); |
283 | bail: |
284 | hpfs_unlock(s: dir->i_sb); |
285 | return err; |
286 | } |
287 | |
288 | static int hpfs_symlink(struct mnt_idmap *idmap, struct inode *dir, |
289 | struct dentry *dentry, const char *symlink) |
290 | { |
291 | const unsigned char *name = dentry->d_name.name; |
292 | unsigned len = dentry->d_name.len; |
293 | struct buffer_head *bh; |
294 | struct fnode *fnode; |
295 | fnode_secno fno; |
296 | int r; |
297 | struct hpfs_dirent dee; |
298 | struct inode *result; |
299 | int err; |
300 | if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err; |
301 | hpfs_lock(s: dir->i_sb); |
302 | if (hpfs_sb(sb: dir->i_sb)->sb_eas < 2) { |
303 | hpfs_unlock(s: dir->i_sb); |
304 | return -EPERM; |
305 | } |
306 | err = -ENOSPC; |
307 | fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(inode: dir)->i_dno, &fno, &bh); |
308 | if (!fnode) |
309 | goto bail; |
310 | memset(&dee, 0, sizeof dee); |
311 | dee.archive = 1; |
312 | dee.hidden = name[0] == '.'; |
313 | dee.fnode = cpu_to_le32(fno); |
314 | dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb)); |
315 | |
316 | result = new_inode(sb: dir->i_sb); |
317 | if (!result) |
318 | goto bail1; |
319 | result->i_ino = fno; |
320 | hpfs_init_inode(result); |
321 | hpfs_i(inode: result)->i_parent_dir = dir->i_ino; |
322 | inode_set_mtime_to_ts(inode: result, |
323 | ts: inode_set_atime_to_ts(inode: result, ts: inode_set_ctime(inode: result, sec: local_to_gmt(s: dir->i_sb, le32_to_cpu(dee.creation_date)), nsec: 0))); |
324 | hpfs_i(inode: result)->i_ea_size = 0; |
325 | result->i_mode = S_IFLNK | 0777; |
326 | result->i_uid = current_fsuid(); |
327 | result->i_gid = current_fsgid(); |
328 | result->i_blocks = 1; |
329 | set_nlink(inode: result, nlink: 1); |
330 | result->i_size = strlen(symlink); |
331 | inode_nohighmem(inode: result); |
332 | result->i_op = &page_symlink_inode_operations; |
333 | result->i_data.a_ops = &hpfs_symlink_aops; |
334 | |
335 | r = hpfs_add_dirent(dir, name, len, &dee); |
336 | if (r == 1) |
337 | goto bail2; |
338 | if (r == -1) { |
339 | err = -EEXIST; |
340 | goto bail2; |
341 | } |
342 | fnode->len = len; |
343 | memcpy(fnode->name, name, len > 15 ? 15 : len); |
344 | fnode->up = cpu_to_le32(dir->i_ino); |
345 | hpfs_set_ea(result, fnode, "SYMLINK" , symlink, strlen(symlink)); |
346 | mark_buffer_dirty(bh); |
347 | brelse(bh); |
348 | |
349 | insert_inode_hash(inode: result); |
350 | |
351 | hpfs_write_inode_nolock(result); |
352 | hpfs_update_directory_times(dir); |
353 | d_instantiate(dentry, result); |
354 | hpfs_unlock(s: dir->i_sb); |
355 | return 0; |
356 | bail2: |
357 | iput(result); |
358 | bail1: |
359 | brelse(bh); |
360 | hpfs_free_sectors(dir->i_sb, fno, 1); |
361 | bail: |
362 | hpfs_unlock(s: dir->i_sb); |
363 | return err; |
364 | } |
365 | |
366 | static int hpfs_unlink(struct inode *dir, struct dentry *dentry) |
367 | { |
368 | const unsigned char *name = dentry->d_name.name; |
369 | unsigned len = dentry->d_name.len; |
370 | struct quad_buffer_head qbh; |
371 | struct hpfs_dirent *de; |
372 | struct inode *inode = d_inode(dentry); |
373 | dnode_secno dno; |
374 | int r; |
375 | int err; |
376 | |
377 | hpfs_lock(s: dir->i_sb); |
378 | hpfs_adjust_length(name, &len); |
379 | |
380 | err = -ENOENT; |
381 | de = map_dirent(dir, hpfs_i(inode: dir)->i_dno, name, len, &dno, &qbh); |
382 | if (!de) |
383 | goto out; |
384 | |
385 | err = -EPERM; |
386 | if (de->first) |
387 | goto out1; |
388 | |
389 | err = -EISDIR; |
390 | if (de->directory) |
391 | goto out1; |
392 | |
393 | r = hpfs_remove_dirent(dir, dno, de, &qbh, 1); |
394 | switch (r) { |
395 | case 1: |
396 | hpfs_error(dir->i_sb, "there was error when removing dirent" ); |
397 | err = -EFSERROR; |
398 | break; |
399 | case 2: /* no space for deleting */ |
400 | err = -ENOSPC; |
401 | break; |
402 | default: |
403 | drop_nlink(inode); |
404 | err = 0; |
405 | } |
406 | goto out; |
407 | |
408 | out1: |
409 | hpfs_brelse4(&qbh); |
410 | out: |
411 | if (!err) |
412 | hpfs_update_directory_times(dir); |
413 | hpfs_unlock(s: dir->i_sb); |
414 | return err; |
415 | } |
416 | |
417 | static int hpfs_rmdir(struct inode *dir, struct dentry *dentry) |
418 | { |
419 | const unsigned char *name = dentry->d_name.name; |
420 | unsigned len = dentry->d_name.len; |
421 | struct quad_buffer_head qbh; |
422 | struct hpfs_dirent *de; |
423 | struct inode *inode = d_inode(dentry); |
424 | dnode_secno dno; |
425 | int n_items = 0; |
426 | int err; |
427 | int r; |
428 | |
429 | hpfs_adjust_length(name, &len); |
430 | hpfs_lock(s: dir->i_sb); |
431 | err = -ENOENT; |
432 | de = map_dirent(dir, hpfs_i(inode: dir)->i_dno, name, len, &dno, &qbh); |
433 | if (!de) |
434 | goto out; |
435 | |
436 | err = -EPERM; |
437 | if (de->first) |
438 | goto out1; |
439 | |
440 | err = -ENOTDIR; |
441 | if (!de->directory) |
442 | goto out1; |
443 | |
444 | hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items); |
445 | err = -ENOTEMPTY; |
446 | if (n_items) |
447 | goto out1; |
448 | |
449 | r = hpfs_remove_dirent(dir, dno, de, &qbh, 1); |
450 | switch (r) { |
451 | case 1: |
452 | hpfs_error(dir->i_sb, "there was error when removing dirent" ); |
453 | err = -EFSERROR; |
454 | break; |
455 | case 2: |
456 | err = -ENOSPC; |
457 | break; |
458 | default: |
459 | drop_nlink(inode: dir); |
460 | clear_nlink(inode); |
461 | err = 0; |
462 | } |
463 | goto out; |
464 | out1: |
465 | hpfs_brelse4(&qbh); |
466 | out: |
467 | if (!err) |
468 | hpfs_update_directory_times(dir); |
469 | hpfs_unlock(s: dir->i_sb); |
470 | return err; |
471 | } |
472 | |
473 | static int hpfs_symlink_read_folio(struct file *file, struct folio *folio) |
474 | { |
475 | struct page *page = &folio->page; |
476 | char *link = page_address(page); |
477 | struct inode *i = page->mapping->host; |
478 | struct fnode *fnode; |
479 | struct buffer_head *bh; |
480 | int err; |
481 | |
482 | err = -EIO; |
483 | hpfs_lock(s: i->i_sb); |
484 | if (!(fnode = hpfs_map_fnode(s: i->i_sb, i->i_ino, &bh))) |
485 | goto fail; |
486 | err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK" , link, PAGE_SIZE); |
487 | brelse(bh); |
488 | if (err) |
489 | goto fail; |
490 | hpfs_unlock(s: i->i_sb); |
491 | SetPageUptodate(page); |
492 | unlock_page(page); |
493 | return 0; |
494 | |
495 | fail: |
496 | hpfs_unlock(s: i->i_sb); |
497 | SetPageError(page); |
498 | unlock_page(page); |
499 | return err; |
500 | } |
501 | |
502 | const struct address_space_operations hpfs_symlink_aops = { |
503 | .read_folio = hpfs_symlink_read_folio |
504 | }; |
505 | |
506 | static int hpfs_rename(struct mnt_idmap *idmap, struct inode *old_dir, |
507 | struct dentry *old_dentry, struct inode *new_dir, |
508 | struct dentry *new_dentry, unsigned int flags) |
509 | { |
510 | const unsigned char *old_name = old_dentry->d_name.name; |
511 | unsigned old_len = old_dentry->d_name.len; |
512 | const unsigned char *new_name = new_dentry->d_name.name; |
513 | unsigned new_len = new_dentry->d_name.len; |
514 | struct inode *i = d_inode(dentry: old_dentry); |
515 | struct inode *new_inode = d_inode(dentry: new_dentry); |
516 | struct quad_buffer_head qbh, qbh1; |
517 | struct hpfs_dirent *dep, *nde; |
518 | struct hpfs_dirent de; |
519 | dnode_secno dno; |
520 | int r; |
521 | struct buffer_head *bh; |
522 | struct fnode *fnode; |
523 | int err; |
524 | |
525 | if (flags & ~RENAME_NOREPLACE) |
526 | return -EINVAL; |
527 | |
528 | if ((err = hpfs_chk_name(new_name, &new_len))) return err; |
529 | err = 0; |
530 | hpfs_adjust_length(old_name, &old_len); |
531 | |
532 | hpfs_lock(s: i->i_sb); |
533 | /* order doesn't matter, due to VFS exclusion */ |
534 | |
535 | /* Erm? Moving over the empty non-busy directory is perfectly legal */ |
536 | if (new_inode && S_ISDIR(new_inode->i_mode)) { |
537 | err = -EINVAL; |
538 | goto end1; |
539 | } |
540 | |
541 | if (!(dep = map_dirent(old_dir, hpfs_i(inode: old_dir)->i_dno, old_name, old_len, &dno, &qbh))) { |
542 | hpfs_error(i->i_sb, "lookup succeeded but map dirent failed" ); |
543 | err = -ENOENT; |
544 | goto end1; |
545 | } |
546 | copy_de(dst: &de, src: dep); |
547 | de.hidden = new_name[0] == '.'; |
548 | |
549 | if (new_inode) { |
550 | int r; |
551 | if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) { |
552 | if ((nde = map_dirent(new_dir, hpfs_i(inode: new_dir)->i_dno, new_name, new_len, NULL, &qbh1))) { |
553 | clear_nlink(inode: new_inode); |
554 | copy_de(dst: nde, src: &de); |
555 | memcpy(nde->name, new_name, new_len); |
556 | hpfs_mark_4buffers_dirty(&qbh1); |
557 | hpfs_brelse4(&qbh1); |
558 | goto end; |
559 | } |
560 | hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent" ); |
561 | err = -EFSERROR; |
562 | goto end1; |
563 | } |
564 | err = -ENOSPC; |
565 | goto end1; |
566 | } |
567 | |
568 | if (new_dir == old_dir) hpfs_brelse4(&qbh); |
569 | |
570 | if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de))) { |
571 | if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!" ); |
572 | err = r == 1 ? -ENOSPC : -EFSERROR; |
573 | if (new_dir != old_dir) hpfs_brelse4(&qbh); |
574 | goto end1; |
575 | } |
576 | |
577 | if (new_dir == old_dir) |
578 | if (!(dep = map_dirent(old_dir, hpfs_i(inode: old_dir)->i_dno, old_name, old_len, &dno, &qbh))) { |
579 | hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2" ); |
580 | err = -ENOENT; |
581 | goto end1; |
582 | } |
583 | |
584 | if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) { |
585 | hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent" ); |
586 | err = r == 2 ? -ENOSPC : -EFSERROR; |
587 | goto end1; |
588 | } |
589 | |
590 | end: |
591 | hpfs_i(inode: i)->i_parent_dir = new_dir->i_ino; |
592 | if (S_ISDIR(i->i_mode)) { |
593 | inc_nlink(inode: new_dir); |
594 | drop_nlink(inode: old_dir); |
595 | } |
596 | if ((fnode = hpfs_map_fnode(s: i->i_sb, i->i_ino, &bh))) { |
597 | fnode->up = cpu_to_le32(new_dir->i_ino); |
598 | fnode->len = new_len; |
599 | memcpy(fnode->name, new_name, new_len>15?15:new_len); |
600 | if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len); |
601 | mark_buffer_dirty(bh); |
602 | brelse(bh); |
603 | } |
604 | end1: |
605 | if (!err) { |
606 | hpfs_update_directory_times(dir: old_dir); |
607 | hpfs_update_directory_times(dir: new_dir); |
608 | } |
609 | hpfs_unlock(s: i->i_sb); |
610 | return err; |
611 | } |
612 | |
613 | const struct inode_operations hpfs_dir_iops = |
614 | { |
615 | .create = hpfs_create, |
616 | .lookup = hpfs_lookup, |
617 | .unlink = hpfs_unlink, |
618 | .symlink = hpfs_symlink, |
619 | .mkdir = hpfs_mkdir, |
620 | .rmdir = hpfs_rmdir, |
621 | .mknod = hpfs_mknod, |
622 | .rename = hpfs_rename, |
623 | .setattr = hpfs_setattr, |
624 | }; |
625 | |