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
12static 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
22static 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;
116bail3:
117 iput(result);
118bail2:
119 hpfs_brelse4(&qbh0);
120 hpfs_free_dnode(dir->i_sb, dno);
121bail1:
122 brelse(bh);
123 hpfs_free_sectors(dir->i_sb, fno, 1);
124bail:
125 hpfs_unlock(s: dir->i_sb);
126 return err;
127}
128
129static 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
205bail2:
206 iput(result);
207bail1:
208 brelse(bh);
209 hpfs_free_sectors(dir->i_sb, fno, 1);
210bail:
211 hpfs_unlock(s: dir->i_sb);
212 return err;
213}
214
215static 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;
278bail2:
279 iput(result);
280bail1:
281 brelse(bh);
282 hpfs_free_sectors(dir->i_sb, fno, 1);
283bail:
284 hpfs_unlock(s: dir->i_sb);
285 return err;
286}
287
288static 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;
356bail2:
357 iput(result);
358bail1:
359 brelse(bh);
360 hpfs_free_sectors(dir->i_sb, fno, 1);
361bail:
362 hpfs_unlock(s: dir->i_sb);
363 return err;
364}
365
366static 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
408out1:
409 hpfs_brelse4(&qbh);
410out:
411 if (!err)
412 hpfs_update_directory_times(dir);
413 hpfs_unlock(s: dir->i_sb);
414 return err;
415}
416
417static 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;
464out1:
465 hpfs_brelse4(&qbh);
466out:
467 if (!err)
468 hpfs_update_directory_times(dir);
469 hpfs_unlock(s: dir->i_sb);
470 return err;
471}
472
473static 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
495fail:
496 hpfs_unlock(s: i->i_sb);
497 SetPageError(page);
498 unlock_page(page);
499 return err;
500}
501
502const struct address_space_operations hpfs_symlink_aops = {
503 .read_folio = hpfs_symlink_read_folio
504};
505
506static 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
590end:
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 }
604end1:
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
613const 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

source code of linux/fs/hpfs/namei.c