GNU Linux-libre 4.9.308-gnu1
[releases.git] / fs / hfsplus / catalog.c
1 /*
2  *  linux/fs/hfsplus/catalog.c
3  *
4  * Copyright (C) 2001
5  * Brad Boyer (flar@allandria.com)
6  * (C) 2003 Ardis Technologies <roman@ardistech.com>
7  *
8  * Handling of catalog records
9  */
10
11
12 #include "hfsplus_fs.h"
13 #include "hfsplus_raw.h"
14
15 int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *k1,
16                              const hfsplus_btree_key *k2)
17 {
18         __be32 k1p, k2p;
19
20         k1p = k1->cat.parent;
21         k2p = k2->cat.parent;
22         if (k1p != k2p)
23                 return be32_to_cpu(k1p) < be32_to_cpu(k2p) ? -1 : 1;
24
25         return hfsplus_strcasecmp(&k1->cat.name, &k2->cat.name);
26 }
27
28 int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *k1,
29                             const hfsplus_btree_key *k2)
30 {
31         __be32 k1p, k2p;
32
33         k1p = k1->cat.parent;
34         k2p = k2->cat.parent;
35         if (k1p != k2p)
36                 return be32_to_cpu(k1p) < be32_to_cpu(k2p) ? -1 : 1;
37
38         return hfsplus_strcmp(&k1->cat.name, &k2->cat.name);
39 }
40
41 /* Generates key for catalog file/folders record. */
42 int hfsplus_cat_build_key(struct super_block *sb,
43                 hfsplus_btree_key *key, u32 parent, const struct qstr *str)
44 {
45         int len, err;
46
47         key->cat.parent = cpu_to_be32(parent);
48         err = hfsplus_asc2uni(sb, &key->cat.name, HFSPLUS_MAX_STRLEN,
49                         str->name, str->len);
50         if (unlikely(err < 0))
51                 return err;
52
53         len = be16_to_cpu(key->cat.name.length);
54         key->key_len = cpu_to_be16(6 + 2 * len);
55         return 0;
56 }
57
58 /* Generates key for catalog thread record. */
59 void hfsplus_cat_build_key_with_cnid(struct super_block *sb,
60                         hfsplus_btree_key *key, u32 parent)
61 {
62         key->cat.parent = cpu_to_be32(parent);
63         key->cat.name.length = 0;
64         key->key_len = cpu_to_be16(6);
65 }
66
67 static void hfsplus_cat_build_key_uni(hfsplus_btree_key *key, u32 parent,
68                                       struct hfsplus_unistr *name)
69 {
70         int ustrlen;
71
72         ustrlen = be16_to_cpu(name->length);
73         key->cat.parent = cpu_to_be32(parent);
74         key->cat.name.length = cpu_to_be16(ustrlen);
75         ustrlen *= 2;
76         memcpy(key->cat.name.unicode, name->unicode, ustrlen);
77         key->key_len = cpu_to_be16(6 + ustrlen);
78 }
79
80 void hfsplus_cat_set_perms(struct inode *inode, struct hfsplus_perm *perms)
81 {
82         if (inode->i_flags & S_IMMUTABLE)
83                 perms->rootflags |= HFSPLUS_FLG_IMMUTABLE;
84         else
85                 perms->rootflags &= ~HFSPLUS_FLG_IMMUTABLE;
86         if (inode->i_flags & S_APPEND)
87                 perms->rootflags |= HFSPLUS_FLG_APPEND;
88         else
89                 perms->rootflags &= ~HFSPLUS_FLG_APPEND;
90
91         perms->userflags = HFSPLUS_I(inode)->userflags;
92         perms->mode = cpu_to_be16(inode->i_mode);
93         perms->owner = cpu_to_be32(i_uid_read(inode));
94         perms->group = cpu_to_be32(i_gid_read(inode));
95
96         if (S_ISREG(inode->i_mode))
97                 perms->dev = cpu_to_be32(inode->i_nlink);
98         else if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode))
99                 perms->dev = cpu_to_be32(inode->i_rdev);
100         else
101                 perms->dev = 0;
102 }
103
104 static int hfsplus_cat_build_record(hfsplus_cat_entry *entry,
105                 u32 cnid, struct inode *inode)
106 {
107         struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
108
109         if (S_ISDIR(inode->i_mode)) {
110                 struct hfsplus_cat_folder *folder;
111
112                 folder = &entry->folder;
113                 memset(folder, 0, sizeof(*folder));
114                 folder->type = cpu_to_be16(HFSPLUS_FOLDER);
115                 if (test_bit(HFSPLUS_SB_HFSX, &sbi->flags))
116                         folder->flags |= cpu_to_be16(HFSPLUS_HAS_FOLDER_COUNT);
117                 folder->id = cpu_to_be32(inode->i_ino);
118                 HFSPLUS_I(inode)->create_date =
119                         folder->create_date =
120                         folder->content_mod_date =
121                         folder->attribute_mod_date =
122                         folder->access_date = hfsp_now2mt();
123                 hfsplus_cat_set_perms(inode, &folder->permissions);
124                 if (inode == sbi->hidden_dir)
125                         /* invisible and namelocked */
126                         folder->user_info.frFlags = cpu_to_be16(0x5000);
127                 return sizeof(*folder);
128         } else {
129                 struct hfsplus_cat_file *file;
130
131                 file = &entry->file;
132                 memset(file, 0, sizeof(*file));
133                 file->type = cpu_to_be16(HFSPLUS_FILE);
134                 file->flags = cpu_to_be16(HFSPLUS_FILE_THREAD_EXISTS);
135                 file->id = cpu_to_be32(cnid);
136                 HFSPLUS_I(inode)->create_date =
137                         file->create_date =
138                         file->content_mod_date =
139                         file->attribute_mod_date =
140                         file->access_date = hfsp_now2mt();
141                 if (cnid == inode->i_ino) {
142                         hfsplus_cat_set_perms(inode, &file->permissions);
143                         if (S_ISLNK(inode->i_mode)) {
144                                 file->user_info.fdType =
145                                         cpu_to_be32(HFSP_SYMLINK_TYPE);
146                                 file->user_info.fdCreator =
147                                         cpu_to_be32(HFSP_SYMLINK_CREATOR);
148                         } else {
149                                 file->user_info.fdType =
150                                         cpu_to_be32(sbi->type);
151                                 file->user_info.fdCreator =
152                                         cpu_to_be32(sbi->creator);
153                         }
154                         if (HFSPLUS_FLG_IMMUTABLE &
155                                         (file->permissions.rootflags |
156                                         file->permissions.userflags))
157                                 file->flags |=
158                                         cpu_to_be16(HFSPLUS_FILE_LOCKED);
159                 } else {
160                         file->user_info.fdType =
161                                 cpu_to_be32(HFSP_HARDLINK_TYPE);
162                         file->user_info.fdCreator =
163                                 cpu_to_be32(HFSP_HFSPLUS_CREATOR);
164                         file->user_info.fdFlags =
165                                 cpu_to_be16(0x100);
166                         file->create_date =
167                                 HFSPLUS_I(sbi->hidden_dir)->create_date;
168                         file->permissions.dev =
169                                 cpu_to_be32(HFSPLUS_I(inode)->linkid);
170                 }
171                 return sizeof(*file);
172         }
173 }
174
175 static int hfsplus_fill_cat_thread(struct super_block *sb,
176                                    hfsplus_cat_entry *entry, int type,
177                                    u32 parentid, const struct qstr *str)
178 {
179         int err;
180
181         entry->type = cpu_to_be16(type);
182         entry->thread.reserved = 0;
183         entry->thread.parentID = cpu_to_be32(parentid);
184         err = hfsplus_asc2uni(sb, &entry->thread.nodeName, HFSPLUS_MAX_STRLEN,
185                                 str->name, str->len);
186         if (unlikely(err < 0))
187                 return err;
188
189         return 10 + be16_to_cpu(entry->thread.nodeName.length) * 2;
190 }
191
192 /* Try to get a catalog entry for given catalog id */
193 int hfsplus_find_cat(struct super_block *sb, u32 cnid,
194                      struct hfs_find_data *fd)
195 {
196         hfsplus_cat_entry tmp;
197         int err;
198         u16 type;
199
200         hfsplus_cat_build_key_with_cnid(sb, fd->search_key, cnid);
201         err = hfs_brec_read(fd, &tmp, sizeof(hfsplus_cat_entry));
202         if (err)
203                 return err;
204
205         type = be16_to_cpu(tmp.type);
206         if (type != HFSPLUS_FOLDER_THREAD && type != HFSPLUS_FILE_THREAD) {
207                 pr_err("found bad thread record in catalog\n");
208                 return -EIO;
209         }
210
211         if (be16_to_cpu(tmp.thread.nodeName.length) > 255) {
212                 pr_err("catalog name length corrupted\n");
213                 return -EIO;
214         }
215
216         hfsplus_cat_build_key_uni(fd->search_key,
217                 be32_to_cpu(tmp.thread.parentID),
218                 &tmp.thread.nodeName);
219         return hfs_brec_find(fd, hfs_find_rec_by_key);
220 }
221
222 static void hfsplus_subfolders_inc(struct inode *dir)
223 {
224         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
225
226         if (test_bit(HFSPLUS_SB_HFSX, &sbi->flags)) {
227                 /*
228                  * Increment subfolder count. Note, the value is only meaningful
229                  * for folders with HFSPLUS_HAS_FOLDER_COUNT flag set.
230                  */
231                 HFSPLUS_I(dir)->subfolders++;
232         }
233 }
234
235 static void hfsplus_subfolders_dec(struct inode *dir)
236 {
237         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
238
239         if (test_bit(HFSPLUS_SB_HFSX, &sbi->flags)) {
240                 /*
241                  * Decrement subfolder count. Note, the value is only meaningful
242                  * for folders with HFSPLUS_HAS_FOLDER_COUNT flag set.
243                  *
244                  * Check for zero. Some subfolders may have been created
245                  * by an implementation ignorant of this counter.
246                  */
247                 if (HFSPLUS_I(dir)->subfolders)
248                         HFSPLUS_I(dir)->subfolders--;
249         }
250 }
251
252 int hfsplus_create_cat(u32 cnid, struct inode *dir,
253                 const struct qstr *str, struct inode *inode)
254 {
255         struct super_block *sb = dir->i_sb;
256         struct hfs_find_data fd;
257         hfsplus_cat_entry entry;
258         int entry_size;
259         int err;
260
261         hfs_dbg(CAT_MOD, "create_cat: %s,%u(%d)\n",
262                 str->name, cnid, inode->i_nlink);
263         err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
264         if (err)
265                 return err;
266
267         /*
268          * Fail early and avoid ENOSPC during the btree operations. We may
269          * have to split the root node at most once.
270          */
271         err = hfs_bmap_reserve(fd.tree, 2 * fd.tree->depth);
272         if (err)
273                 goto err2;
274
275         hfsplus_cat_build_key_with_cnid(sb, fd.search_key, cnid);
276         entry_size = hfsplus_fill_cat_thread(sb, &entry,
277                 S_ISDIR(inode->i_mode) ?
278                         HFSPLUS_FOLDER_THREAD : HFSPLUS_FILE_THREAD,
279                 dir->i_ino, str);
280         if (unlikely(entry_size < 0)) {
281                 err = entry_size;
282                 goto err2;
283         }
284
285         err = hfs_brec_find(&fd, hfs_find_rec_by_key);
286         if (err != -ENOENT) {
287                 if (!err)
288                         err = -EEXIST;
289                 goto err2;
290         }
291         err = hfs_brec_insert(&fd, &entry, entry_size);
292         if (err)
293                 goto err2;
294
295         err = hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, str);
296         if (unlikely(err))
297                 goto err1;
298
299         entry_size = hfsplus_cat_build_record(&entry, cnid, inode);
300         err = hfs_brec_find(&fd, hfs_find_rec_by_key);
301         if (err != -ENOENT) {
302                 /* panic? */
303                 if (!err)
304                         err = -EEXIST;
305                 goto err1;
306         }
307         err = hfs_brec_insert(&fd, &entry, entry_size);
308         if (err)
309                 goto err1;
310
311         dir->i_size++;
312         if (S_ISDIR(inode->i_mode))
313                 hfsplus_subfolders_inc(dir);
314         dir->i_mtime = dir->i_ctime = current_time(dir);
315         hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY);
316
317         hfs_find_exit(&fd);
318         return 0;
319
320 err1:
321         hfsplus_cat_build_key_with_cnid(sb, fd.search_key, cnid);
322         if (!hfs_brec_find(&fd, hfs_find_rec_by_key))
323                 hfs_brec_remove(&fd);
324 err2:
325         hfs_find_exit(&fd);
326         return err;
327 }
328
329 int hfsplus_delete_cat(u32 cnid, struct inode *dir, const struct qstr *str)
330 {
331         struct super_block *sb = dir->i_sb;
332         struct hfs_find_data fd;
333         struct hfsplus_fork_raw fork;
334         struct list_head *pos;
335         int err, off;
336         u16 type;
337
338         hfs_dbg(CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid);
339         err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
340         if (err)
341                 return err;
342
343         /*
344          * Fail early and avoid ENOSPC during the btree operations. We may
345          * have to split the root node at most once.
346          */
347         err = hfs_bmap_reserve(fd.tree, 2 * (int)fd.tree->depth - 2);
348         if (err)
349                 goto out;
350
351         if (!str) {
352                 int len;
353
354                 hfsplus_cat_build_key_with_cnid(sb, fd.search_key, cnid);
355                 err = hfs_brec_find(&fd, hfs_find_rec_by_key);
356                 if (err)
357                         goto out;
358
359                 off = fd.entryoffset +
360                         offsetof(struct hfsplus_cat_thread, nodeName);
361                 fd.search_key->cat.parent = cpu_to_be32(dir->i_ino);
362                 hfs_bnode_read(fd.bnode,
363                         &fd.search_key->cat.name.length, off, 2);
364                 len = be16_to_cpu(fd.search_key->cat.name.length) * 2;
365                 hfs_bnode_read(fd.bnode,
366                         &fd.search_key->cat.name.unicode,
367                         off + 2, len);
368                 fd.search_key->key_len = cpu_to_be16(6 + len);
369         } else {
370                 err = hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, str);
371                 if (unlikely(err))
372                         goto out;
373         }
374
375         err = hfs_brec_find(&fd, hfs_find_rec_by_key);
376         if (err)
377                 goto out;
378
379         type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset);
380         if (type == HFSPLUS_FILE) {
381 #if 0
382                 off = fd.entryoffset + offsetof(hfsplus_cat_file, data_fork);
383                 hfs_bnode_read(fd.bnode, &fork, off, sizeof(fork));
384                 hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_DATA);
385 #endif
386
387                 off = fd.entryoffset +
388                         offsetof(struct hfsplus_cat_file, rsrc_fork);
389                 hfs_bnode_read(fd.bnode, &fork, off, sizeof(fork));
390                 hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_RSRC);
391         }
392
393         /* we only need to take spinlock for exclusion with ->release() */
394         spin_lock(&HFSPLUS_I(dir)->open_dir_lock);
395         list_for_each(pos, &HFSPLUS_I(dir)->open_dir_list) {
396                 struct hfsplus_readdir_data *rd =
397                         list_entry(pos, struct hfsplus_readdir_data, list);
398                 if (fd.tree->keycmp(fd.search_key, (void *)&rd->key) < 0)
399                         rd->file->f_pos--;
400         }
401         spin_unlock(&HFSPLUS_I(dir)->open_dir_lock);
402
403         err = hfs_brec_remove(&fd);
404         if (err)
405                 goto out;
406
407         hfsplus_cat_build_key_with_cnid(sb, fd.search_key, cnid);
408         err = hfs_brec_find(&fd, hfs_find_rec_by_key);
409         if (err)
410                 goto out;
411
412         err = hfs_brec_remove(&fd);
413         if (err)
414                 goto out;
415
416         dir->i_size--;
417         if (type == HFSPLUS_FOLDER)
418                 hfsplus_subfolders_dec(dir);
419         dir->i_mtime = dir->i_ctime = current_time(dir);
420         hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY);
421
422         if (type == HFSPLUS_FILE || type == HFSPLUS_FOLDER) {
423                 if (HFSPLUS_SB(sb)->attr_tree)
424                         hfsplus_delete_all_attrs(dir, cnid);
425         }
426
427 out:
428         hfs_find_exit(&fd);
429
430         return err;
431 }
432
433 int hfsplus_rename_cat(u32 cnid,
434                        struct inode *src_dir, const struct qstr *src_name,
435                        struct inode *dst_dir, const struct qstr *dst_name)
436 {
437         struct super_block *sb = src_dir->i_sb;
438         struct hfs_find_data src_fd, dst_fd;
439         hfsplus_cat_entry entry;
440         int entry_size, type;
441         int err;
442
443         hfs_dbg(CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n",
444                 cnid, src_dir->i_ino, src_name->name,
445                 dst_dir->i_ino, dst_name->name);
446         err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &src_fd);
447         if (err)
448                 return err;
449         dst_fd = src_fd;
450
451         /*
452          * Fail early and avoid ENOSPC during the btree operations. We may
453          * have to split the root node at most twice.
454          */
455         err = hfs_bmap_reserve(src_fd.tree, 4 * (int)src_fd.tree->depth - 1);
456         if (err)
457                 goto out;
458
459         /* find the old dir entry and read the data */
460         err = hfsplus_cat_build_key(sb, src_fd.search_key,
461                         src_dir->i_ino, src_name);
462         if (unlikely(err))
463                 goto out;
464
465         err = hfs_brec_find(&src_fd, hfs_find_rec_by_key);
466         if (err)
467                 goto out;
468         if (src_fd.entrylength > sizeof(entry) || src_fd.entrylength < 0) {
469                 err = -EIO;
470                 goto out;
471         }
472
473         hfs_bnode_read(src_fd.bnode, &entry, src_fd.entryoffset,
474                                 src_fd.entrylength);
475         type = be16_to_cpu(entry.type);
476
477         /* create new dir entry with the data from the old entry */
478         err = hfsplus_cat_build_key(sb, dst_fd.search_key,
479                         dst_dir->i_ino, dst_name);
480         if (unlikely(err))
481                 goto out;
482
483         err = hfs_brec_find(&dst_fd, hfs_find_rec_by_key);
484         if (err != -ENOENT) {
485                 if (!err)
486                         err = -EEXIST;
487                 goto out;
488         }
489
490         err = hfs_brec_insert(&dst_fd, &entry, src_fd.entrylength);
491         if (err)
492                 goto out;
493         dst_dir->i_size++;
494         if (type == HFSPLUS_FOLDER)
495                 hfsplus_subfolders_inc(dst_dir);
496         dst_dir->i_mtime = dst_dir->i_ctime = current_time(dst_dir);
497
498         /* finally remove the old entry */
499         err = hfsplus_cat_build_key(sb, src_fd.search_key,
500                         src_dir->i_ino, src_name);
501         if (unlikely(err))
502                 goto out;
503
504         err = hfs_brec_find(&src_fd, hfs_find_rec_by_key);
505         if (err)
506                 goto out;
507         err = hfs_brec_remove(&src_fd);
508         if (err)
509                 goto out;
510         src_dir->i_size--;
511         if (type == HFSPLUS_FOLDER)
512                 hfsplus_subfolders_dec(src_dir);
513         src_dir->i_mtime = src_dir->i_ctime = current_time(src_dir);
514
515         /* remove old thread entry */
516         hfsplus_cat_build_key_with_cnid(sb, src_fd.search_key, cnid);
517         err = hfs_brec_find(&src_fd, hfs_find_rec_by_key);
518         if (err)
519                 goto out;
520         type = hfs_bnode_read_u16(src_fd.bnode, src_fd.entryoffset);
521         err = hfs_brec_remove(&src_fd);
522         if (err)
523                 goto out;
524
525         /* create new thread entry */
526         hfsplus_cat_build_key_with_cnid(sb, dst_fd.search_key, cnid);
527         entry_size = hfsplus_fill_cat_thread(sb, &entry, type,
528                 dst_dir->i_ino, dst_name);
529         if (unlikely(entry_size < 0)) {
530                 err = entry_size;
531                 goto out;
532         }
533
534         err = hfs_brec_find(&dst_fd, hfs_find_rec_by_key);
535         if (err != -ENOENT) {
536                 if (!err)
537                         err = -EEXIST;
538                 goto out;
539         }
540         err = hfs_brec_insert(&dst_fd, &entry, entry_size);
541
542         hfsplus_mark_inode_dirty(dst_dir, HFSPLUS_I_CAT_DIRTY);
543         hfsplus_mark_inode_dirty(src_dir, HFSPLUS_I_CAT_DIRTY);
544 out:
545         hfs_bnode_put(dst_fd.bnode);
546         hfs_find_exit(&src_fd);
547         return err;
548 }