1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
54
55#include <linux/slab.h>
56#include <linux/spinlock.h>
57#include <linux/buffer_head.h>
58#include <linux/sort.h>
59#include <linux/gfs2_ondisk.h>
60#include <linux/crc32.h>
61#include <linux/vmalloc.h>
62#include <linux/bio.h>
63
64#include "gfs2.h"
65#include "incore.h"
66#include "dir.h"
67#include "glock.h"
68#include "inode.h"
69#include "meta_io.h"
70#include "quota.h"
71#include "rgrp.h"
72#include "trans.h"
73#include "bmap.h"
74#include "util.h"
75
76#define MAX_RA_BLOCKS 32
77
78#define gfs2_disk_hash2offset(h) (((u64)(h)) >> 1)
79#define gfs2_dir_offset2hash(p) ((u32)(((u64)(p)) << 1))
80#define GFS2_HASH_INDEX_MASK 0xffffc000
81#define GFS2_USE_HASH_FLAG 0x2000
82
83struct qstr gfs2_qdot __read_mostly;
84struct qstr gfs2_qdotdot __read_mostly;
85
86typedef int (*gfs2_dscan_t)(const struct gfs2_dirent *dent,
87 const struct qstr *name, void *opaque);
88
89int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, u64 block,
90 struct buffer_head **bhp)
91{
92 struct buffer_head *bh;
93
94 bh = gfs2_meta_new(ip->i_gl, block);
95 gfs2_trans_add_meta(ip->i_gl, bh);
96 gfs2_metatype_set(bh, GFS2_METATYPE_JD, GFS2_FORMAT_JD);
97 gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
98 *bhp = bh;
99 return 0;
100}
101
102static int gfs2_dir_get_existing_buffer(struct gfs2_inode *ip, u64 block,
103 struct buffer_head **bhp)
104{
105 struct buffer_head *bh;
106 int error;
107
108 error = gfs2_meta_read(ip->i_gl, block, DIO_WAIT, 0, &bh);
109 if (error)
110 return error;
111 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_JD)) {
112 brelse(bh);
113 return -EIO;
114 }
115 *bhp = bh;
116 return 0;
117}
118
119static int gfs2_dir_write_stuffed(struct gfs2_inode *ip, const char *buf,
120 unsigned int offset, unsigned int size)
121{
122 struct buffer_head *dibh;
123 int error;
124
125 error = gfs2_meta_inode_buffer(ip, &dibh);
126 if (error)
127 return error;
128
129 gfs2_trans_add_meta(ip->i_gl, dibh);
130 memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);
131 if (ip->i_inode.i_size < offset + size)
132 i_size_write(&ip->i_inode, offset + size);
133 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
134 gfs2_dinode_out(ip, dibh->b_data);
135
136 brelse(dibh);
137
138 return size;
139}
140
141
142
143
144
145
146
147
148
149
150
151
152static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,
153 u64 offset, unsigned int size)
154{
155 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
156 struct buffer_head *dibh;
157 u64 lblock, dblock;
158 u32 extlen = 0;
159 unsigned int o;
160 int copied = 0;
161 int error = 0;
162 bool new = false;
163
164 if (!size)
165 return 0;
166
167 if (gfs2_is_stuffed(ip) && offset + size <= gfs2_max_stuffed_size(ip))
168 return gfs2_dir_write_stuffed(ip, buf, (unsigned int)offset,
169 size);
170
171 if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
172 return -EINVAL;
173
174 if (gfs2_is_stuffed(ip)) {
175 error = gfs2_unstuff_dinode(ip);
176 if (error)
177 return error;
178 }
179
180 lblock = offset;
181 o = do_div(lblock, sdp->sd_jbsize) + sizeof(struct gfs2_meta_header);
182
183 while (copied < size) {
184 unsigned int amount;
185 struct buffer_head *bh;
186
187 amount = size - copied;
188 if (amount > sdp->sd_sb.sb_bsize - o)
189 amount = sdp->sd_sb.sb_bsize - o;
190
191 if (!extlen) {
192 extlen = 1;
193 error = gfs2_alloc_extent(&ip->i_inode, lblock, &dblock,
194 &extlen, &new);
195 if (error)
196 goto fail;
197 error = -EIO;
198 if (gfs2_assert_withdraw(sdp, dblock))
199 goto fail;
200 }
201
202 if (amount == sdp->sd_jbsize || new)
203 error = gfs2_dir_get_new_buffer(ip, dblock, &bh);
204 else
205 error = gfs2_dir_get_existing_buffer(ip, dblock, &bh);
206
207 if (error)
208 goto fail;
209
210 gfs2_trans_add_meta(ip->i_gl, bh);
211 memcpy(bh->b_data + o, buf, amount);
212 brelse(bh);
213
214 buf += amount;
215 copied += amount;
216 lblock++;
217 dblock++;
218 extlen--;
219
220 o = sizeof(struct gfs2_meta_header);
221 }
222
223out:
224 error = gfs2_meta_inode_buffer(ip, &dibh);
225 if (error)
226 return error;
227
228 if (ip->i_inode.i_size < offset + copied)
229 i_size_write(&ip->i_inode, offset + copied);
230 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
231
232 gfs2_trans_add_meta(ip->i_gl, dibh);
233 gfs2_dinode_out(ip, dibh->b_data);
234 brelse(dibh);
235
236 return copied;
237fail:
238 if (copied)
239 goto out;
240 return error;
241}
242
243static int gfs2_dir_read_stuffed(struct gfs2_inode *ip, __be64 *buf,
244 unsigned int size)
245{
246 struct buffer_head *dibh;
247 int error;
248
249 error = gfs2_meta_inode_buffer(ip, &dibh);
250 if (!error) {
251 memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
252 brelse(dibh);
253 }
254
255 return (error) ? error : size;
256}
257
258
259
260
261
262
263
264
265
266
267static int gfs2_dir_read_data(struct gfs2_inode *ip, __be64 *buf,
268 unsigned int size)
269{
270 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
271 u64 lblock, dblock;
272 u32 extlen = 0;
273 unsigned int o;
274 int copied = 0;
275 int error = 0;
276
277 if (gfs2_is_stuffed(ip))
278 return gfs2_dir_read_stuffed(ip, buf, size);
279
280 if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
281 return -EINVAL;
282
283 lblock = 0;
284 o = do_div(lblock, sdp->sd_jbsize) + sizeof(struct gfs2_meta_header);
285
286 while (copied < size) {
287 unsigned int amount;
288 struct buffer_head *bh;
289
290 amount = size - copied;
291 if (amount > sdp->sd_sb.sb_bsize - o)
292 amount = sdp->sd_sb.sb_bsize - o;
293
294 if (!extlen) {
295 extlen = 32;
296 error = gfs2_get_extent(&ip->i_inode, lblock,
297 &dblock, &extlen);
298 if (error || !dblock)
299 goto fail;
300 BUG_ON(extlen < 1);
301 bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
302 } else {
303 error = gfs2_meta_read(ip->i_gl, dblock, DIO_WAIT, 0, &bh);
304 if (error)
305 goto fail;
306 }
307 error = gfs2_metatype_check(sdp, bh, GFS2_METATYPE_JD);
308 if (error) {
309 brelse(bh);
310 goto fail;
311 }
312 dblock++;
313 extlen--;
314 memcpy(buf, bh->b_data + o, amount);
315 brelse(bh);
316 buf += (amount/sizeof(__be64));
317 copied += amount;
318 lblock++;
319 o = sizeof(struct gfs2_meta_header);
320 }
321
322 return copied;
323fail:
324 return (copied) ? copied : error;
325}
326
327
328
329
330
331
332
333
334static __be64 *gfs2_dir_get_hash_table(struct gfs2_inode *ip)
335{
336 struct inode *inode = &ip->i_inode;
337 int ret;
338 u32 hsize;
339 __be64 *hc;
340
341 BUG_ON(!(ip->i_diskflags & GFS2_DIF_EXHASH));
342
343 hc = ip->i_hash_cache;
344 if (hc)
345 return hc;
346
347 hsize = BIT(ip->i_depth);
348 hsize *= sizeof(__be64);
349 if (hsize != i_size_read(&ip->i_inode)) {
350 gfs2_consist_inode(ip);
351 return ERR_PTR(-EIO);
352 }
353
354 hc = kmalloc(hsize, GFP_NOFS | __GFP_NOWARN);
355 if (hc == NULL)
356 hc = __vmalloc(hsize, GFP_NOFS);
357
358 if (hc == NULL)
359 return ERR_PTR(-ENOMEM);
360
361 ret = gfs2_dir_read_data(ip, hc, hsize);
362 if (ret < 0) {
363 kvfree(hc);
364 return ERR_PTR(ret);
365 }
366
367 spin_lock(&inode->i_lock);
368 if (likely(!ip->i_hash_cache)) {
369 ip->i_hash_cache = hc;
370 hc = NULL;
371 }
372 spin_unlock(&inode->i_lock);
373 kvfree(hc);
374
375 return ip->i_hash_cache;
376}
377
378
379
380
381
382
383
384void gfs2_dir_hash_inval(struct gfs2_inode *ip)
385{
386 __be64 *hc;
387
388 spin_lock(&ip->i_inode.i_lock);
389 hc = ip->i_hash_cache;
390 ip->i_hash_cache = NULL;
391 spin_unlock(&ip->i_inode.i_lock);
392
393 kvfree(hc);
394}
395
396static inline int gfs2_dirent_sentinel(const struct gfs2_dirent *dent)
397{
398 return dent->de_inum.no_addr == 0 || dent->de_inum.no_formal_ino == 0;
399}
400
401static inline int __gfs2_dirent_find(const struct gfs2_dirent *dent,
402 const struct qstr *name, int ret)
403{
404 if (!gfs2_dirent_sentinel(dent) &&
405 be32_to_cpu(dent->de_hash) == name->hash &&
406 be16_to_cpu(dent->de_name_len) == name->len &&
407 memcmp(dent+1, name->name, name->len) == 0)
408 return ret;
409 return 0;
410}
411
412static int gfs2_dirent_find(const struct gfs2_dirent *dent,
413 const struct qstr *name,
414 void *opaque)
415{
416 return __gfs2_dirent_find(dent, name, 1);
417}
418
419static int gfs2_dirent_prev(const struct gfs2_dirent *dent,
420 const struct qstr *name,
421 void *opaque)
422{
423 return __gfs2_dirent_find(dent, name, 2);
424}
425
426
427
428
429
430static int gfs2_dirent_last(const struct gfs2_dirent *dent,
431 const struct qstr *name,
432 void *opaque)
433{
434 const char *start = name->name;
435 const char *end = (const char *)dent + be16_to_cpu(dent->de_rec_len);
436 if (name->len == (end - start))
437 return 1;
438 return 0;
439}
440
441
442
443static int gfs2_dirent_find_offset(const struct gfs2_dirent *dent,
444 const struct qstr *name,
445 void *ptr)
446{
447 unsigned required = GFS2_DIRENT_SIZE(name->len);
448 unsigned actual = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
449 unsigned totlen = be16_to_cpu(dent->de_rec_len);
450
451 if (ptr < (void *)dent || ptr >= (void *)dent + totlen)
452 return 0;
453 if (gfs2_dirent_sentinel(dent))
454 actual = 0;
455 if (ptr < (void *)dent + actual)
456 return -1;
457 if ((void *)dent + totlen >= ptr + required)
458 return 1;
459 return -1;
460}
461
462static int gfs2_dirent_find_space(const struct gfs2_dirent *dent,
463 const struct qstr *name,
464 void *opaque)
465{
466 unsigned required = GFS2_DIRENT_SIZE(name->len);
467 unsigned actual = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
468 unsigned totlen = be16_to_cpu(dent->de_rec_len);
469
470 if (gfs2_dirent_sentinel(dent))
471 actual = 0;
472 if (totlen - actual >= required)
473 return 1;
474 return 0;
475}
476
477struct dirent_gather {
478 const struct gfs2_dirent **pdent;
479 unsigned offset;
480};
481
482static int gfs2_dirent_gather(const struct gfs2_dirent *dent,
483 const struct qstr *name,
484 void *opaque)
485{
486 struct dirent_gather *g = opaque;
487 if (!gfs2_dirent_sentinel(dent)) {
488 g->pdent[g->offset++] = dent;
489 }
490 return 0;
491}
492
493
494
495
496
497
498
499
500
501
502static int gfs2_check_dirent(struct gfs2_sbd *sdp,
503 struct gfs2_dirent *dent, unsigned int offset,
504 unsigned int size, unsigned int len, int first)
505{
506 const char *msg = "gfs2_dirent too small";
507 if (unlikely(size < sizeof(struct gfs2_dirent)))
508 goto error;
509 msg = "gfs2_dirent misaligned";
510 if (unlikely(offset & 0x7))
511 goto error;
512 msg = "gfs2_dirent points beyond end of block";
513 if (unlikely(offset + size > len))
514 goto error;
515 msg = "zero inode number";
516 if (unlikely(!first && gfs2_dirent_sentinel(dent)))
517 goto error;
518 msg = "name length is greater than space in dirent";
519 if (!gfs2_dirent_sentinel(dent) &&
520 unlikely(sizeof(struct gfs2_dirent)+be16_to_cpu(dent->de_name_len) >
521 size))
522 goto error;
523 return 0;
524error:
525 fs_warn(sdp, "%s: %s (%s)\n",
526 __func__, msg, first ? "first in block" : "not first in block");
527 return -EIO;
528}
529
530static int gfs2_dirent_offset(struct gfs2_sbd *sdp, const void *buf)
531{
532 const struct gfs2_meta_header *h = buf;
533 int offset;
534
535 BUG_ON(buf == NULL);
536
537 switch(be32_to_cpu(h->mh_type)) {
538 case GFS2_METATYPE_LF:
539 offset = sizeof(struct gfs2_leaf);
540 break;
541 case GFS2_METATYPE_DI:
542 offset = sizeof(struct gfs2_dinode);
543 break;
544 default:
545 goto wrong_type;
546 }
547 return offset;
548wrong_type:
549 fs_warn(sdp, "%s: wrong block type %u\n", __func__,
550 be32_to_cpu(h->mh_type));
551 return -1;
552}
553
554static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode, void *buf,
555 unsigned int len, gfs2_dscan_t scan,
556 const struct qstr *name,
557 void *opaque)
558{
559 struct gfs2_dirent *dent, *prev;
560 unsigned offset;
561 unsigned size;
562 int ret = 0;
563
564 ret = gfs2_dirent_offset(GFS2_SB(inode), buf);
565 if (ret < 0)
566 goto consist_inode;
567
568 offset = ret;
569 prev = NULL;
570 dent = buf + offset;
571 size = be16_to_cpu(dent->de_rec_len);
572 if (gfs2_check_dirent(GFS2_SB(inode), dent, offset, size, len, 1))
573 goto consist_inode;
574 do {
575 ret = scan(dent, name, opaque);
576 if (ret)
577 break;
578 offset += size;
579 if (offset == len)
580 break;
581 prev = dent;
582 dent = buf + offset;
583 size = be16_to_cpu(dent->de_rec_len);
584 if (gfs2_check_dirent(GFS2_SB(inode), dent, offset, size,
585 len, 0))
586 goto consist_inode;
587 } while(1);
588
589 switch(ret) {
590 case 0:
591 return NULL;
592 case 1:
593 return dent;
594 case 2:
595 return prev ? prev : dent;
596 default:
597 BUG_ON(ret > 0);
598 return ERR_PTR(ret);
599 }
600
601consist_inode:
602 gfs2_consist_inode(GFS2_I(inode));
603 return ERR_PTR(-EIO);
604}
605
606static int dirent_check_reclen(struct gfs2_inode *dip,
607 const struct gfs2_dirent *d, const void *end_p)
608{
609 const void *ptr = d;
610 u16 rec_len = be16_to_cpu(d->de_rec_len);
611
612 if (unlikely(rec_len < sizeof(struct gfs2_dirent)))
613 goto broken;
614 ptr += rec_len;
615 if (ptr < end_p)
616 return rec_len;
617 if (ptr == end_p)
618 return -ENOENT;
619broken:
620 gfs2_consist_inode(dip);
621 return -EIO;
622}
623
624
625
626
627
628
629
630
631
632
633static int dirent_next(struct gfs2_inode *dip, struct buffer_head *bh,
634 struct gfs2_dirent **dent)
635{
636 struct gfs2_dirent *cur = *dent, *tmp;
637 char *bh_end = bh->b_data + bh->b_size;
638 int ret;
639
640 ret = dirent_check_reclen(dip, cur, bh_end);
641 if (ret < 0)
642 return ret;
643
644 tmp = (void *)cur + ret;
645 ret = dirent_check_reclen(dip, tmp, bh_end);
646 if (ret == -EIO)
647 return ret;
648
649
650 if (gfs2_dirent_sentinel(tmp)) {
651 gfs2_consist_inode(dip);
652 return -EIO;
653 }
654
655 *dent = tmp;
656 return 0;
657}
658
659
660
661
662
663
664
665
666
667
668static void dirent_del(struct gfs2_inode *dip, struct buffer_head *bh,
669 struct gfs2_dirent *prev, struct gfs2_dirent *cur)
670{
671 u16 cur_rec_len, prev_rec_len;
672
673 if (gfs2_dirent_sentinel(cur)) {
674 gfs2_consist_inode(dip);
675 return;
676 }
677
678 gfs2_trans_add_meta(dip->i_gl, bh);
679
680
681
682
683
684 if (!prev) {
685 cur->de_inum.no_addr = 0;
686 cur->de_inum.no_formal_ino = 0;
687 return;
688 }
689
690
691
692 prev_rec_len = be16_to_cpu(prev->de_rec_len);
693 cur_rec_len = be16_to_cpu(cur->de_rec_len);
694
695 if ((char *)prev + prev_rec_len != (char *)cur)
696 gfs2_consist_inode(dip);
697 if ((char *)cur + cur_rec_len > bh->b_data + bh->b_size)
698 gfs2_consist_inode(dip);
699
700 prev_rec_len += cur_rec_len;
701 prev->de_rec_len = cpu_to_be16(prev_rec_len);
702}
703
704
705static struct gfs2_dirent *do_init_dirent(struct inode *inode,
706 struct gfs2_dirent *dent,
707 const struct qstr *name,
708 struct buffer_head *bh,
709 unsigned offset)
710{
711 struct gfs2_inode *ip = GFS2_I(inode);
712 struct gfs2_dirent *ndent;
713 unsigned totlen;
714
715 totlen = be16_to_cpu(dent->de_rec_len);
716 BUG_ON(offset + name->len > totlen);
717 gfs2_trans_add_meta(ip->i_gl, bh);
718 ndent = (struct gfs2_dirent *)((char *)dent + offset);
719 dent->de_rec_len = cpu_to_be16(offset);
720 gfs2_qstr2dirent(name, totlen - offset, ndent);
721 return ndent;
722}
723
724
725
726
727
728
729static struct gfs2_dirent *gfs2_init_dirent(struct inode *inode,
730 struct gfs2_dirent *dent,
731 const struct qstr *name,
732 struct buffer_head *bh)
733{
734 unsigned offset = 0;
735
736 if (!gfs2_dirent_sentinel(dent))
737 offset = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
738 return do_init_dirent(inode, dent, name, bh, offset);
739}
740
741static struct gfs2_dirent *gfs2_dirent_split_alloc(struct inode *inode,
742 struct buffer_head *bh,
743 const struct qstr *name,
744 void *ptr)
745{
746 struct gfs2_dirent *dent;
747 dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
748 gfs2_dirent_find_offset, name, ptr);
749 if (IS_ERR_OR_NULL(dent))
750 return dent;
751 return do_init_dirent(inode, dent, name, bh,
752 (unsigned)(ptr - (void *)dent));
753}
754
755static int get_leaf(struct gfs2_inode *dip, u64 leaf_no,
756 struct buffer_head **bhp)
757{
758 int error;
759
760 error = gfs2_meta_read(dip->i_gl, leaf_no, DIO_WAIT, 0, bhp);
761 if (!error && gfs2_metatype_check(GFS2_SB(&dip->i_inode), *bhp, GFS2_METATYPE_LF)) {
762
763 error = -EIO;
764 }
765
766 return error;
767}
768
769
770
771
772
773
774
775
776
777
778static int get_leaf_nr(struct gfs2_inode *dip, u32 index, u64 *leaf_out)
779{
780 __be64 *hash;
781 int error;
782
783 hash = gfs2_dir_get_hash_table(dip);
784 error = PTR_ERR_OR_ZERO(hash);
785
786 if (!error)
787 *leaf_out = be64_to_cpu(*(hash + index));
788
789 return error;
790}
791
792static int get_first_leaf(struct gfs2_inode *dip, u32 index,
793 struct buffer_head **bh_out)
794{
795 u64 leaf_no;
796 int error;
797
798 error = get_leaf_nr(dip, index, &leaf_no);
799 if (!error)
800 error = get_leaf(dip, leaf_no, bh_out);
801
802 return error;
803}
804
805static struct gfs2_dirent *gfs2_dirent_search(struct inode *inode,
806 const struct qstr *name,
807 gfs2_dscan_t scan,
808 struct buffer_head **pbh)
809{
810 struct buffer_head *bh;
811 struct gfs2_dirent *dent;
812 struct gfs2_inode *ip = GFS2_I(inode);
813 int error;
814
815 if (ip->i_diskflags & GFS2_DIF_EXHASH) {
816 struct gfs2_leaf *leaf;
817 unsigned int hsize = BIT(ip->i_depth);
818 unsigned int index;
819 u64 ln;
820 if (hsize * sizeof(u64) != i_size_read(inode)) {
821 gfs2_consist_inode(ip);
822 return ERR_PTR(-EIO);
823 }
824
825 index = name->hash >> (32 - ip->i_depth);
826 error = get_first_leaf(ip, index, &bh);
827 if (error)
828 return ERR_PTR(error);
829 do {
830 dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
831 scan, name, NULL);
832 if (dent)
833 goto got_dent;
834 leaf = (struct gfs2_leaf *)bh->b_data;
835 ln = be64_to_cpu(leaf->lf_next);
836 brelse(bh);
837 if (!ln)
838 break;
839
840 error = get_leaf(ip, ln, &bh);
841 } while(!error);
842
843 return error ? ERR_PTR(error) : NULL;
844 }
845
846
847 error = gfs2_meta_inode_buffer(ip, &bh);
848 if (error)
849 return ERR_PTR(error);
850 dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size, scan, name, NULL);
851got_dent:
852 if (IS_ERR_OR_NULL(dent)) {
853 brelse(bh);
854 bh = NULL;
855 }
856 *pbh = bh;
857 return dent;
858}
859
860static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, u16 depth)
861{
862 struct gfs2_inode *ip = GFS2_I(inode);
863 unsigned int n = 1;
864 u64 bn;
865 int error;
866 struct buffer_head *bh;
867 struct gfs2_leaf *leaf;
868 struct gfs2_dirent *dent;
869 struct timespec64 tv = current_time(inode);
870
871 error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
872 if (error)
873 return NULL;
874 bh = gfs2_meta_new(ip->i_gl, bn);
875 if (!bh)
876 return NULL;
877
878 gfs2_trans_remove_revoke(GFS2_SB(inode), bn, 1);
879 gfs2_trans_add_meta(ip->i_gl, bh);
880 gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);
881 leaf = (struct gfs2_leaf *)bh->b_data;
882 leaf->lf_depth = cpu_to_be16(depth);
883 leaf->lf_entries = 0;
884 leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
885 leaf->lf_next = 0;
886 leaf->lf_inode = cpu_to_be64(ip->i_no_addr);
887 leaf->lf_dist = cpu_to_be32(1);
888 leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
889 leaf->lf_sec = cpu_to_be64(tv.tv_sec);
890 memset(leaf->lf_reserved2, 0, sizeof(leaf->lf_reserved2));
891 dent = (struct gfs2_dirent *)(leaf+1);
892 gfs2_qstr2dirent(&empty_name, bh->b_size - sizeof(struct gfs2_leaf), dent);
893 *pbh = bh;
894 return leaf;
895}
896
897
898
899
900
901
902
903
904static int dir_make_exhash(struct inode *inode)
905{
906 struct gfs2_inode *dip = GFS2_I(inode);
907 struct gfs2_sbd *sdp = GFS2_SB(inode);
908 struct gfs2_dirent *dent;
909 struct qstr args;
910 struct buffer_head *bh, *dibh;
911 struct gfs2_leaf *leaf;
912 int y;
913 u32 x;
914 __be64 *lp;
915 u64 bn;
916 int error;
917
918 error = gfs2_meta_inode_buffer(dip, &dibh);
919 if (error)
920 return error;
921
922
923
924 leaf = new_leaf(inode, &bh, 0);
925 if (!leaf)
926 return -ENOSPC;
927 bn = bh->b_blocknr;
928
929 gfs2_assert(sdp, dip->i_entries < BIT(16));
930 leaf->lf_entries = cpu_to_be16(dip->i_entries);
931
932
933
934 gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_leaf), dibh,
935 sizeof(struct gfs2_dinode));
936
937
938
939 x = 0;
940 args.len = bh->b_size - sizeof(struct gfs2_dinode) +
941 sizeof(struct gfs2_leaf);
942 args.name = bh->b_data;
943 dent = gfs2_dirent_scan(&dip->i_inode, bh->b_data, bh->b_size,
944 gfs2_dirent_last, &args, NULL);
945 if (!dent) {
946 brelse(bh);
947 brelse(dibh);
948 return -EIO;
949 }
950 if (IS_ERR(dent)) {
951 brelse(bh);
952 brelse(dibh);
953 return PTR_ERR(dent);
954 }
955
956
957
958
959 dent->de_rec_len = cpu_to_be16(be16_to_cpu(dent->de_rec_len) +
960 sizeof(struct gfs2_dinode) -
961 sizeof(struct gfs2_leaf));
962
963 brelse(bh);
964
965
966
967
968 gfs2_trans_add_meta(dip->i_gl, dibh);
969 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
970
971 lp = (__be64 *)(dibh->b_data + sizeof(struct gfs2_dinode));
972
973 for (x = sdp->sd_hash_ptrs; x--; lp++)
974 *lp = cpu_to_be64(bn);
975
976 i_size_write(inode, sdp->sd_sb.sb_bsize / 2);
977 gfs2_add_inode_blocks(&dip->i_inode, 1);
978 dip->i_diskflags |= GFS2_DIF_EXHASH;
979
980 for (x = sdp->sd_hash_ptrs, y = -1; x; x >>= 1, y++) ;
981 dip->i_depth = y;
982
983 gfs2_dinode_out(dip, dibh->b_data);
984
985 brelse(dibh);
986
987 return 0;
988}
989
990
991
992
993
994
995
996
997
998static int dir_split_leaf(struct inode *inode, const struct qstr *name)
999{
1000 struct gfs2_inode *dip = GFS2_I(inode);
1001 struct buffer_head *nbh, *obh, *dibh;
1002 struct gfs2_leaf *nleaf, *oleaf;
1003 struct gfs2_dirent *dent = NULL, *prev = NULL, *next = NULL, *new;
1004 u32 start, len, half_len, divider;
1005 u64 bn, leaf_no;
1006 __be64 *lp;
1007 u32 index;
1008 int x;
1009 int error;
1010
1011 index = name->hash >> (32 - dip->i_depth);
1012 error = get_leaf_nr(dip, index, &leaf_no);
1013 if (error)
1014 return error;
1015
1016
1017 error = get_leaf(dip, leaf_no, &obh);
1018 if (error)
1019 return error;
1020
1021 oleaf = (struct gfs2_leaf *)obh->b_data;
1022 if (dip->i_depth == be16_to_cpu(oleaf->lf_depth)) {
1023 brelse(obh);
1024 return 1;
1025 }
1026
1027 gfs2_trans_add_meta(dip->i_gl, obh);
1028
1029 nleaf = new_leaf(inode, &nbh, be16_to_cpu(oleaf->lf_depth) + 1);
1030 if (!nleaf) {
1031 brelse(obh);
1032 return -ENOSPC;
1033 }
1034 bn = nbh->b_blocknr;
1035
1036
1037 len = BIT(dip->i_depth - be16_to_cpu(oleaf->lf_depth));
1038 half_len = len >> 1;
1039 if (!half_len) {
1040 fs_warn(GFS2_SB(inode), "i_depth %u lf_depth %u index %u\n",
1041 dip->i_depth, be16_to_cpu(oleaf->lf_depth), index);
1042 gfs2_consist_inode(dip);
1043 error = -EIO;
1044 goto fail_brelse;
1045 }
1046
1047 start = (index & ~(len - 1));
1048
1049
1050
1051
1052 lp = kmalloc_array(half_len, sizeof(__be64), GFP_NOFS);
1053 if (!lp) {
1054 error = -ENOMEM;
1055 goto fail_brelse;
1056 }
1057
1058
1059 for (x = 0; x < half_len; x++)
1060 lp[x] = cpu_to_be64(bn);
1061
1062 gfs2_dir_hash_inval(dip);
1063
1064 error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(u64),
1065 half_len * sizeof(u64));
1066 if (error != half_len * sizeof(u64)) {
1067 if (error >= 0)
1068 error = -EIO;
1069 goto fail_lpfree;
1070 }
1071
1072 kfree(lp);
1073
1074
1075 divider = (start + half_len) << (32 - dip->i_depth);
1076
1077
1078 dent = (struct gfs2_dirent *)(obh->b_data + sizeof(struct gfs2_leaf));
1079
1080 do {
1081 next = dent;
1082 if (dirent_next(dip, obh, &next))
1083 next = NULL;
1084
1085 if (!gfs2_dirent_sentinel(dent) &&
1086 be32_to_cpu(dent->de_hash) < divider) {
1087 struct qstr str;
1088 void *ptr = ((char *)dent - obh->b_data) + nbh->b_data;
1089 str.name = (char*)(dent+1);
1090 str.len = be16_to_cpu(dent->de_name_len);
1091 str.hash = be32_to_cpu(dent->de_hash);
1092 new = gfs2_dirent_split_alloc(inode, nbh, &str, ptr);
1093 if (IS_ERR(new)) {
1094 error = PTR_ERR(new);
1095 break;
1096 }
1097
1098 new->de_inum = dent->de_inum;
1099 new->de_type = dent->de_type;
1100 be16_add_cpu(&nleaf->lf_entries, 1);
1101
1102 dirent_del(dip, obh, prev, dent);
1103
1104 if (!oleaf->lf_entries)
1105 gfs2_consist_inode(dip);
1106 be16_add_cpu(&oleaf->lf_entries, -1);
1107
1108 if (!prev)
1109 prev = dent;
1110 } else {
1111 prev = dent;
1112 }
1113 dent = next;
1114 } while (dent);
1115
1116 oleaf->lf_depth = nleaf->lf_depth;
1117
1118 error = gfs2_meta_inode_buffer(dip, &dibh);
1119 if (!gfs2_assert_withdraw(GFS2_SB(&dip->i_inode), !error)) {
1120 gfs2_trans_add_meta(dip->i_gl, dibh);
1121 gfs2_add_inode_blocks(&dip->i_inode, 1);
1122 gfs2_dinode_out(dip, dibh->b_data);
1123 brelse(dibh);
1124 }
1125
1126 brelse(obh);
1127 brelse(nbh);
1128
1129 return error;
1130
1131fail_lpfree:
1132 kfree(lp);
1133
1134fail_brelse:
1135 brelse(obh);
1136 brelse(nbh);
1137 return error;
1138}
1139
1140
1141
1142
1143
1144
1145
1146
1147static int dir_double_exhash(struct gfs2_inode *dip)
1148{
1149 struct buffer_head *dibh;
1150 u32 hsize;
1151 u32 hsize_bytes;
1152 __be64 *hc;
1153 __be64 *hc2, *h;
1154 int x;
1155 int error = 0;
1156
1157 hsize = BIT(dip->i_depth);
1158 hsize_bytes = hsize * sizeof(__be64);
1159
1160 hc = gfs2_dir_get_hash_table(dip);
1161 if (IS_ERR(hc))
1162 return PTR_ERR(hc);
1163
1164 hc2 = kmalloc_array(hsize_bytes, 2, GFP_NOFS | __GFP_NOWARN);
1165 if (hc2 == NULL)
1166 hc2 = __vmalloc(hsize_bytes * 2, GFP_NOFS);
1167
1168 if (!hc2)
1169 return -ENOMEM;
1170
1171 h = hc2;
1172 error = gfs2_meta_inode_buffer(dip, &dibh);
1173 if (error)
1174 goto out_kfree;
1175
1176 for (x = 0; x < hsize; x++) {
1177 *h++ = *hc;
1178 *h++ = *hc;
1179 hc++;
1180 }
1181
1182 error = gfs2_dir_write_data(dip, (char *)hc2, 0, hsize_bytes * 2);
1183 if (error != (hsize_bytes * 2))
1184 goto fail;
1185
1186 gfs2_dir_hash_inval(dip);
1187 dip->i_hash_cache = hc2;
1188 dip->i_depth++;
1189 gfs2_dinode_out(dip, dibh->b_data);
1190 brelse(dibh);
1191 return 0;
1192
1193fail:
1194
1195 gfs2_dir_write_data(dip, (char *)hc, 0, hsize_bytes);
1196 i_size_write(&dip->i_inode, hsize_bytes);
1197 gfs2_dinode_out(dip, dibh->b_data);
1198 brelse(dibh);
1199out_kfree:
1200 kvfree(hc2);
1201 return error;
1202}
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215static int compare_dents(const void *a, const void *b)
1216{
1217 const struct gfs2_dirent *dent_a, *dent_b;
1218 u32 hash_a, hash_b;
1219 int ret = 0;
1220
1221 dent_a = *(const struct gfs2_dirent **)a;
1222 hash_a = dent_a->de_cookie;
1223
1224 dent_b = *(const struct gfs2_dirent **)b;
1225 hash_b = dent_b->de_cookie;
1226
1227 if (hash_a > hash_b)
1228 ret = 1;
1229 else if (hash_a < hash_b)
1230 ret = -1;
1231 else {
1232 unsigned int len_a = be16_to_cpu(dent_a->de_name_len);
1233 unsigned int len_b = be16_to_cpu(dent_b->de_name_len);
1234
1235 if (len_a > len_b)
1236 ret = 1;
1237 else if (len_a < len_b)
1238 ret = -1;
1239 else
1240 ret = memcmp(dent_a + 1, dent_b + 1, len_a);
1241 }
1242
1243 return ret;
1244}
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263static int do_filldir_main(struct gfs2_inode *dip, struct dir_context *ctx,
1264 struct gfs2_dirent **darr, u32 entries,
1265 u32 sort_start, int *copied)
1266{
1267 const struct gfs2_dirent *dent, *dent_next;
1268 u64 off, off_next;
1269 unsigned int x, y;
1270 int run = 0;
1271
1272 if (sort_start < entries)
1273 sort(&darr[sort_start], entries - sort_start,
1274 sizeof(struct gfs2_dirent *), compare_dents, NULL);
1275
1276 dent_next = darr[0];
1277 off_next = dent_next->de_cookie;
1278
1279 for (x = 0, y = 1; x < entries; x++, y++) {
1280 dent = dent_next;
1281 off = off_next;
1282
1283 if (y < entries) {
1284 dent_next = darr[y];
1285 off_next = dent_next->de_cookie;
1286
1287 if (off < ctx->pos)
1288 continue;
1289 ctx->pos = off;
1290
1291 if (off_next == off) {
1292 if (*copied && !run)
1293 return 1;
1294 run = 1;
1295 } else
1296 run = 0;
1297 } else {
1298 if (off < ctx->pos)
1299 continue;
1300 ctx->pos = off;
1301 }
1302
1303 if (!dir_emit(ctx, (const char *)(dent + 1),
1304 be16_to_cpu(dent->de_name_len),
1305 be64_to_cpu(dent->de_inum.no_addr),
1306 be16_to_cpu(dent->de_type)))
1307 return 1;
1308
1309 *copied = 1;
1310 }
1311
1312
1313
1314
1315
1316 ctx->pos++;
1317
1318 return 0;
1319}
1320
1321static void *gfs2_alloc_sort_buffer(unsigned size)
1322{
1323 void *ptr = NULL;
1324
1325 if (size < KMALLOC_MAX_SIZE)
1326 ptr = kmalloc(size, GFP_NOFS | __GFP_NOWARN);
1327 if (!ptr)
1328 ptr = __vmalloc(size, GFP_NOFS);
1329 return ptr;
1330}
1331
1332
1333static int gfs2_set_cookies(struct gfs2_sbd *sdp, struct buffer_head *bh,
1334 unsigned leaf_nr, struct gfs2_dirent **darr,
1335 unsigned entries)
1336{
1337 int sort_id = -1;
1338 int i;
1339
1340 for (i = 0; i < entries; i++) {
1341 unsigned offset;
1342
1343 darr[i]->de_cookie = be32_to_cpu(darr[i]->de_hash);
1344 darr[i]->de_cookie = gfs2_disk_hash2offset(darr[i]->de_cookie);
1345
1346 if (!sdp->sd_args.ar_loccookie)
1347 continue;
1348 offset = (char *)(darr[i]) -
1349 (bh->b_data + gfs2_dirent_offset(sdp, bh->b_data));
1350 offset /= GFS2_MIN_DIRENT_SIZE;
1351 offset += leaf_nr * sdp->sd_max_dents_per_leaf;
1352 if (offset >= GFS2_USE_HASH_FLAG ||
1353 leaf_nr >= GFS2_USE_HASH_FLAG) {
1354 darr[i]->de_cookie |= GFS2_USE_HASH_FLAG;
1355 if (sort_id < 0)
1356 sort_id = i;
1357 continue;
1358 }
1359 darr[i]->de_cookie &= GFS2_HASH_INDEX_MASK;
1360 darr[i]->de_cookie |= offset;
1361 }
1362 return sort_id;
1363}
1364
1365
1366static int gfs2_dir_read_leaf(struct inode *inode, struct dir_context *ctx,
1367 int *copied, unsigned *depth,
1368 u64 leaf_no)
1369{
1370 struct gfs2_inode *ip = GFS2_I(inode);
1371 struct gfs2_sbd *sdp = GFS2_SB(inode);
1372 struct buffer_head *bh;
1373 struct gfs2_leaf *lf;
1374 unsigned entries = 0, entries2 = 0;
1375 unsigned leaves = 0, leaf = 0, offset, sort_offset;
1376 struct gfs2_dirent **darr, *dent;
1377 struct dirent_gather g;
1378 struct buffer_head **larr;
1379 int error, i, need_sort = 0, sort_id;
1380 u64 lfn = leaf_no;
1381
1382 do {
1383 error = get_leaf(ip, lfn, &bh);
1384 if (error)
1385 goto out;
1386 lf = (struct gfs2_leaf *)bh->b_data;
1387 if (leaves == 0)
1388 *depth = be16_to_cpu(lf->lf_depth);
1389 entries += be16_to_cpu(lf->lf_entries);
1390 leaves++;
1391 lfn = be64_to_cpu(lf->lf_next);
1392 brelse(bh);
1393 } while(lfn);
1394
1395 if (*depth < GFS2_DIR_MAX_DEPTH || !sdp->sd_args.ar_loccookie) {
1396 need_sort = 1;
1397 sort_offset = 0;
1398 }
1399
1400 if (!entries)
1401 return 0;
1402
1403 error = -ENOMEM;
1404
1405
1406
1407
1408
1409
1410 larr = gfs2_alloc_sort_buffer((leaves + entries + 99) * sizeof(void *));
1411 if (!larr)
1412 goto out;
1413 darr = (struct gfs2_dirent **)(larr + leaves);
1414 g.pdent = (const struct gfs2_dirent **)darr;
1415 g.offset = 0;
1416 lfn = leaf_no;
1417
1418 do {
1419 error = get_leaf(ip, lfn, &bh);
1420 if (error)
1421 goto out_free;
1422 lf = (struct gfs2_leaf *)bh->b_data;
1423 lfn = be64_to_cpu(lf->lf_next);
1424 if (lf->lf_entries) {
1425 offset = g.offset;
1426 entries2 += be16_to_cpu(lf->lf_entries);
1427 dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
1428 gfs2_dirent_gather, NULL, &g);
1429 error = PTR_ERR(dent);
1430 if (IS_ERR(dent))
1431 goto out_free;
1432 if (entries2 != g.offset) {
1433 fs_warn(sdp, "Number of entries corrupt in dir "
1434 "leaf %llu, entries2 (%u) != "
1435 "g.offset (%u)\n",
1436 (unsigned long long)bh->b_blocknr,
1437 entries2, g.offset);
1438 gfs2_consist_inode(ip);
1439 error = -EIO;
1440 goto out_free;
1441 }
1442 error = 0;
1443 sort_id = gfs2_set_cookies(sdp, bh, leaf, &darr[offset],
1444 be16_to_cpu(lf->lf_entries));
1445 if (!need_sort && sort_id >= 0) {
1446 need_sort = 1;
1447 sort_offset = offset + sort_id;
1448 }
1449 larr[leaf++] = bh;
1450 } else {
1451 larr[leaf++] = NULL;
1452 brelse(bh);
1453 }
1454 } while(lfn);
1455
1456 BUG_ON(entries2 != entries);
1457 error = do_filldir_main(ip, ctx, darr, entries, need_sort ?
1458 sort_offset : entries, copied);
1459out_free:
1460 for(i = 0; i < leaf; i++)
1461 brelse(larr[i]);
1462 kvfree(larr);
1463out:
1464 return error;
1465}
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479static void gfs2_dir_readahead(struct inode *inode, unsigned hsize, u32 index,
1480 struct file_ra_state *f_ra)
1481{
1482 struct gfs2_inode *ip = GFS2_I(inode);
1483 struct gfs2_glock *gl = ip->i_gl;
1484 struct buffer_head *bh;
1485 u64 blocknr = 0, last;
1486 unsigned count;
1487
1488
1489 if (index + MAX_RA_BLOCKS < f_ra->start)
1490 return;
1491
1492 f_ra->start = max((pgoff_t)index, f_ra->start);
1493 for (count = 0; count < MAX_RA_BLOCKS; count++) {
1494 if (f_ra->start >= hsize)
1495 break;
1496
1497 last = blocknr;
1498 blocknr = be64_to_cpu(ip->i_hash_cache[f_ra->start]);
1499 f_ra->start++;
1500 if (blocknr == last)
1501 continue;
1502
1503 bh = gfs2_getbuf(gl, blocknr, 1);
1504 if (trylock_buffer(bh)) {
1505 if (buffer_uptodate(bh)) {
1506 unlock_buffer(bh);
1507 brelse(bh);
1508 continue;
1509 }
1510 bh->b_end_io = end_buffer_read_sync;
1511 submit_bh(REQ_OP_READ,
1512 REQ_RAHEAD | REQ_META | REQ_PRIO,
1513 bh);
1514 continue;
1515 }
1516 brelse(bh);
1517 }
1518}
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529static int dir_e_read(struct inode *inode, struct dir_context *ctx,
1530 struct file_ra_state *f_ra)
1531{
1532 struct gfs2_inode *dip = GFS2_I(inode);
1533 u32 hsize, len = 0;
1534 u32 hash, index;
1535 __be64 *lp;
1536 int copied = 0;
1537 int error = 0;
1538 unsigned depth = 0;
1539
1540 hsize = BIT(dip->i_depth);
1541 hash = gfs2_dir_offset2hash(ctx->pos);
1542 index = hash >> (32 - dip->i_depth);
1543
1544 if (dip->i_hash_cache == NULL)
1545 f_ra->start = 0;
1546 lp = gfs2_dir_get_hash_table(dip);
1547 if (IS_ERR(lp))
1548 return PTR_ERR(lp);
1549
1550 gfs2_dir_readahead(inode, hsize, index, f_ra);
1551
1552 while (index < hsize) {
1553 error = gfs2_dir_read_leaf(inode, ctx,
1554 &copied, &depth,
1555 be64_to_cpu(lp[index]));
1556 if (error)
1557 break;
1558
1559 len = BIT(dip->i_depth - depth);
1560 index = (index & ~(len - 1)) + len;
1561 }
1562
1563 if (error > 0)
1564 error = 0;
1565 return error;
1566}
1567
1568int gfs2_dir_read(struct inode *inode, struct dir_context *ctx,
1569 struct file_ra_state *f_ra)
1570{
1571 struct gfs2_inode *dip = GFS2_I(inode);
1572 struct gfs2_sbd *sdp = GFS2_SB(inode);
1573 struct dirent_gather g;
1574 struct gfs2_dirent **darr, *dent;
1575 struct buffer_head *dibh;
1576 int copied = 0;
1577 int error;
1578
1579 if (!dip->i_entries)
1580 return 0;
1581
1582 if (dip->i_diskflags & GFS2_DIF_EXHASH)
1583 return dir_e_read(inode, ctx, f_ra);
1584
1585 if (!gfs2_is_stuffed(dip)) {
1586 gfs2_consist_inode(dip);
1587 return -EIO;
1588 }
1589
1590 error = gfs2_meta_inode_buffer(dip, &dibh);
1591 if (error)
1592 return error;
1593
1594 error = -ENOMEM;
1595
1596 darr = kmalloc_array(96, sizeof(struct gfs2_dirent *), GFP_NOFS);
1597 if (darr) {
1598 g.pdent = (const struct gfs2_dirent **)darr;
1599 g.offset = 0;
1600 dent = gfs2_dirent_scan(inode, dibh->b_data, dibh->b_size,
1601 gfs2_dirent_gather, NULL, &g);
1602 if (IS_ERR(dent)) {
1603 error = PTR_ERR(dent);
1604 goto out;
1605 }
1606 if (dip->i_entries != g.offset) {
1607 fs_warn(sdp, "Number of entries corrupt in dir %llu, "
1608 "ip->i_entries (%u) != g.offset (%u)\n",
1609 (unsigned long long)dip->i_no_addr,
1610 dip->i_entries,
1611 g.offset);
1612 gfs2_consist_inode(dip);
1613 error = -EIO;
1614 goto out;
1615 }
1616 gfs2_set_cookies(sdp, dibh, 0, darr, dip->i_entries);
1617 error = do_filldir_main(dip, ctx, darr,
1618 dip->i_entries, 0, &copied);
1619out:
1620 kfree(darr);
1621 }
1622
1623 if (error > 0)
1624 error = 0;
1625
1626 brelse(dibh);
1627
1628 return error;
1629}
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name,
1644 bool fail_on_exist)
1645{
1646 struct buffer_head *bh;
1647 struct gfs2_dirent *dent;
1648 u64 addr, formal_ino;
1649 u16 dtype;
1650
1651 dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
1652 if (dent) {
1653 struct inode *inode;
1654 u16 rahead;
1655
1656 if (IS_ERR(dent))
1657 return ERR_CAST(dent);
1658 dtype = be16_to_cpu(dent->de_type);
1659 rahead = be16_to_cpu(dent->de_rahead);
1660 addr = be64_to_cpu(dent->de_inum.no_addr);
1661 formal_ino = be64_to_cpu(dent->de_inum.no_formal_ino);
1662 brelse(bh);
1663 if (fail_on_exist)
1664 return ERR_PTR(-EEXIST);
1665 inode = gfs2_inode_lookup(dir->i_sb, dtype, addr, formal_ino,
1666 GFS2_BLKST_FREE );
1667 if (!IS_ERR(inode))
1668 GFS2_I(inode)->i_rahead = rahead;
1669 return inode;
1670 }
1671 return ERR_PTR(-ENOENT);
1672}
1673
1674int gfs2_dir_check(struct inode *dir, const struct qstr *name,
1675 const struct gfs2_inode *ip)
1676{
1677 struct buffer_head *bh;
1678 struct gfs2_dirent *dent;
1679 int ret = -ENOENT;
1680
1681 dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
1682 if (dent) {
1683 if (IS_ERR(dent))
1684 return PTR_ERR(dent);
1685 if (ip) {
1686 if (be64_to_cpu(dent->de_inum.no_addr) != ip->i_no_addr)
1687 goto out;
1688 if (be64_to_cpu(dent->de_inum.no_formal_ino) !=
1689 ip->i_no_formal_ino)
1690 goto out;
1691 if (unlikely(IF2DT(ip->i_inode.i_mode) !=
1692 be16_to_cpu(dent->de_type))) {
1693 gfs2_consist_inode(GFS2_I(dir));
1694 ret = -EIO;
1695 goto out;
1696 }
1697 }
1698 ret = 0;
1699out:
1700 brelse(bh);
1701 }
1702 return ret;
1703}
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724static int dir_new_leaf(struct inode *inode, const struct qstr *name)
1725{
1726 struct buffer_head *bh, *obh;
1727 struct gfs2_inode *ip = GFS2_I(inode);
1728 struct gfs2_leaf *leaf, *oleaf;
1729 u32 dist = 1;
1730 int error;
1731 u32 index;
1732 u64 bn;
1733
1734 index = name->hash >> (32 - ip->i_depth);
1735 error = get_first_leaf(ip, index, &obh);
1736 if (error)
1737 return error;
1738 do {
1739 dist++;
1740 oleaf = (struct gfs2_leaf *)obh->b_data;
1741 bn = be64_to_cpu(oleaf->lf_next);
1742 if (!bn)
1743 break;
1744 brelse(obh);
1745 error = get_leaf(ip, bn, &obh);
1746 if (error)
1747 return error;
1748 } while(1);
1749
1750 gfs2_trans_add_meta(ip->i_gl, obh);
1751
1752 leaf = new_leaf(inode, &bh, be16_to_cpu(oleaf->lf_depth));
1753 if (!leaf) {
1754 brelse(obh);
1755 return -ENOSPC;
1756 }
1757 leaf->lf_dist = cpu_to_be32(dist);
1758 oleaf->lf_next = cpu_to_be64(bh->b_blocknr);
1759 brelse(bh);
1760 brelse(obh);
1761
1762 error = gfs2_meta_inode_buffer(ip, &bh);
1763 if (error)
1764 return error;
1765 gfs2_trans_add_meta(ip->i_gl, bh);
1766 gfs2_add_inode_blocks(&ip->i_inode, 1);
1767 gfs2_dinode_out(ip, bh->b_data);
1768 brelse(bh);
1769 return 0;
1770}
1771
1772static u16 gfs2_inode_ra_len(const struct gfs2_inode *ip)
1773{
1774 u64 where = ip->i_no_addr + 1;
1775 if (ip->i_eattr == where)
1776 return 1;
1777 return 0;
1778}
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796int gfs2_dir_add(struct inode *inode, const struct qstr *name,
1797 const struct gfs2_inode *nip, struct gfs2_diradd *da)
1798{
1799 struct gfs2_inode *ip = GFS2_I(inode);
1800 struct buffer_head *bh = da->bh;
1801 struct gfs2_dirent *dent = da->dent;
1802 struct timespec64 tv;
1803 struct gfs2_leaf *leaf;
1804 int error;
1805
1806 while(1) {
1807 if (da->bh == NULL) {
1808 dent = gfs2_dirent_search(inode, name,
1809 gfs2_dirent_find_space, &bh);
1810 }
1811 if (dent) {
1812 if (IS_ERR(dent))
1813 return PTR_ERR(dent);
1814 dent = gfs2_init_dirent(inode, dent, name, bh);
1815 gfs2_inum_out(nip, dent);
1816 dent->de_type = cpu_to_be16(IF2DT(nip->i_inode.i_mode));
1817 dent->de_rahead = cpu_to_be16(gfs2_inode_ra_len(nip));
1818 tv = current_time(&ip->i_inode);
1819 if (ip->i_diskflags & GFS2_DIF_EXHASH) {
1820 leaf = (struct gfs2_leaf *)bh->b_data;
1821 be16_add_cpu(&leaf->lf_entries, 1);
1822 leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
1823 leaf->lf_sec = cpu_to_be64(tv.tv_sec);
1824 }
1825 da->dent = NULL;
1826 da->bh = NULL;
1827 brelse(bh);
1828 ip->i_entries++;
1829 ip->i_inode.i_mtime = ip->i_inode.i_ctime = tv;
1830 if (S_ISDIR(nip->i_inode.i_mode))
1831 inc_nlink(&ip->i_inode);
1832 mark_inode_dirty(inode);
1833 error = 0;
1834 break;
1835 }
1836 if (!(ip->i_diskflags & GFS2_DIF_EXHASH)) {
1837 error = dir_make_exhash(inode);
1838 if (error)
1839 break;
1840 continue;
1841 }
1842 error = dir_split_leaf(inode, name);
1843 if (error == 0)
1844 continue;
1845 if (error < 0)
1846 break;
1847 if (ip->i_depth < GFS2_DIR_MAX_DEPTH) {
1848 error = dir_double_exhash(ip);
1849 if (error)
1850 break;
1851 error = dir_split_leaf(inode, name);
1852 if (error < 0)
1853 break;
1854 if (error == 0)
1855 continue;
1856 }
1857 error = dir_new_leaf(inode, name);
1858 if (!error)
1859 continue;
1860 error = -ENOSPC;
1861 break;
1862 }
1863 return error;
1864}
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875int gfs2_dir_del(struct gfs2_inode *dip, const struct dentry *dentry)
1876{
1877 const struct qstr *name = &dentry->d_name;
1878 struct gfs2_dirent *dent, *prev = NULL;
1879 struct buffer_head *bh;
1880 struct timespec64 tv = current_time(&dip->i_inode);
1881
1882
1883
1884 dent = gfs2_dirent_search(&dip->i_inode, name, gfs2_dirent_prev, &bh);
1885 if (!dent) {
1886 gfs2_consist_inode(dip);
1887 return -EIO;
1888 }
1889 if (IS_ERR(dent)) {
1890 gfs2_consist_inode(dip);
1891 return PTR_ERR(dent);
1892 }
1893
1894 if (gfs2_dirent_find(dent, name, NULL) == 0) {
1895 prev = dent;
1896 dent = (struct gfs2_dirent *)((char *)dent + be16_to_cpu(prev->de_rec_len));
1897 }
1898
1899 dirent_del(dip, bh, prev, dent);
1900 if (dip->i_diskflags & GFS2_DIF_EXHASH) {
1901 struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
1902 u16 entries = be16_to_cpu(leaf->lf_entries);
1903 if (!entries)
1904 gfs2_consist_inode(dip);
1905 leaf->lf_entries = cpu_to_be16(--entries);
1906 leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
1907 leaf->lf_sec = cpu_to_be64(tv.tv_sec);
1908 }
1909 brelse(bh);
1910
1911 if (!dip->i_entries)
1912 gfs2_consist_inode(dip);
1913 dip->i_entries--;
1914 dip->i_inode.i_mtime = dip->i_inode.i_ctime = tv;
1915 if (d_is_dir(dentry))
1916 drop_nlink(&dip->i_inode);
1917 mark_inode_dirty(&dip->i_inode);
1918
1919 return 0;
1920}
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
1937 const struct gfs2_inode *nip, unsigned int new_type)
1938{
1939 struct buffer_head *bh;
1940 struct gfs2_dirent *dent;
1941
1942 dent = gfs2_dirent_search(&dip->i_inode, filename, gfs2_dirent_find, &bh);
1943 if (!dent) {
1944 gfs2_consist_inode(dip);
1945 return -EIO;
1946 }
1947 if (IS_ERR(dent))
1948 return PTR_ERR(dent);
1949
1950 gfs2_trans_add_meta(dip->i_gl, bh);
1951 gfs2_inum_out(nip, dent);
1952 dent->de_type = cpu_to_be16(new_type);
1953 brelse(bh);
1954
1955 dip->i_inode.i_mtime = dip->i_inode.i_ctime = current_time(&dip->i_inode);
1956 mark_inode_dirty_sync(&dip->i_inode);
1957 return 0;
1958}
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len,
1973 u64 leaf_no, struct buffer_head *leaf_bh,
1974 int last_dealloc)
1975{
1976 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
1977 struct gfs2_leaf *tmp_leaf;
1978 struct gfs2_rgrp_list rlist;
1979 struct buffer_head *bh, *dibh;
1980 u64 blk, nblk;
1981 unsigned int rg_blocks = 0, l_blocks = 0;
1982 char *ht;
1983 unsigned int x, size = len * sizeof(u64);
1984 int error;
1985
1986 error = gfs2_rindex_update(sdp);
1987 if (error)
1988 return error;
1989
1990 memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
1991
1992 ht = kzalloc(size, GFP_NOFS | __GFP_NOWARN);
1993 if (ht == NULL)
1994 ht = __vmalloc(size, GFP_NOFS | __GFP_NOWARN | __GFP_ZERO);
1995 if (!ht)
1996 return -ENOMEM;
1997
1998 error = gfs2_quota_hold(dip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
1999 if (error)
2000 goto out;
2001
2002
2003 bh = leaf_bh;
2004
2005 for (blk = leaf_no; blk; blk = nblk) {
2006 if (blk != leaf_no) {
2007 error = get_leaf(dip, blk, &bh);
2008 if (error)
2009 goto out_rlist;
2010 }
2011 tmp_leaf = (struct gfs2_leaf *)bh->b_data;
2012 nblk = be64_to_cpu(tmp_leaf->lf_next);
2013 if (blk != leaf_no)
2014 brelse(bh);
2015
2016 gfs2_rlist_add(dip, &rlist, blk);
2017 l_blocks++;
2018 }
2019
2020 gfs2_rlist_alloc(&rlist);
2021
2022 for (x = 0; x < rlist.rl_rgrps; x++) {
2023 struct gfs2_rgrpd *rgd = gfs2_glock2rgrp(rlist.rl_ghs[x].gh_gl);
2024
2025 rg_blocks += rgd->rd_length;
2026 }
2027
2028 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
2029 if (error)
2030 goto out_rlist;
2031
2032 error = gfs2_trans_begin(sdp,
2033 rg_blocks + (DIV_ROUND_UP(size, sdp->sd_jbsize) + 1) +
2034 RES_DINODE + RES_STATFS + RES_QUOTA, RES_DINODE +
2035 l_blocks);
2036 if (error)
2037 goto out_rg_gunlock;
2038
2039 bh = leaf_bh;
2040
2041 for (blk = leaf_no; blk; blk = nblk) {
2042 struct gfs2_rgrpd *rgd;
2043
2044 if (blk != leaf_no) {
2045 error = get_leaf(dip, blk, &bh);
2046 if (error)
2047 goto out_end_trans;
2048 }
2049 tmp_leaf = (struct gfs2_leaf *)bh->b_data;
2050 nblk = be64_to_cpu(tmp_leaf->lf_next);
2051 if (blk != leaf_no)
2052 brelse(bh);
2053
2054 rgd = gfs2_blk2rgrpd(sdp, blk, true);
2055 gfs2_free_meta(dip, rgd, blk, 1);
2056 gfs2_add_inode_blocks(&dip->i_inode, -1);
2057 }
2058
2059 error = gfs2_dir_write_data(dip, ht, index * sizeof(u64), size);
2060 if (error != size) {
2061 if (error >= 0)
2062 error = -EIO;
2063 goto out_end_trans;
2064 }
2065
2066 error = gfs2_meta_inode_buffer(dip, &dibh);
2067 if (error)
2068 goto out_end_trans;
2069
2070 gfs2_trans_add_meta(dip->i_gl, dibh);
2071
2072
2073 if (last_dealloc)
2074 dip->i_inode.i_mode = S_IFREG;
2075 gfs2_dinode_out(dip, dibh->b_data);
2076 brelse(dibh);
2077
2078out_end_trans:
2079 gfs2_trans_end(sdp);
2080out_rg_gunlock:
2081 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
2082out_rlist:
2083 gfs2_rlist_free(&rlist);
2084 gfs2_quota_unhold(dip);
2085out:
2086 kvfree(ht);
2087 return error;
2088}
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip)
2101{
2102 struct buffer_head *bh;
2103 struct gfs2_leaf *leaf;
2104 u32 hsize, len;
2105 u32 index = 0, next_index;
2106 __be64 *lp;
2107 u64 leaf_no;
2108 int error = 0, last;
2109
2110 hsize = BIT(dip->i_depth);
2111
2112 lp = gfs2_dir_get_hash_table(dip);
2113 if (IS_ERR(lp))
2114 return PTR_ERR(lp);
2115
2116 while (index < hsize) {
2117 leaf_no = be64_to_cpu(lp[index]);
2118 if (leaf_no) {
2119 error = get_leaf(dip, leaf_no, &bh);
2120 if (error)
2121 goto out;
2122 leaf = (struct gfs2_leaf *)bh->b_data;
2123 len = BIT(dip->i_depth - be16_to_cpu(leaf->lf_depth));
2124
2125 next_index = (index & ~(len - 1)) + len;
2126 last = ((next_index >= hsize) ? 1 : 0);
2127 error = leaf_dealloc(dip, index, len, leaf_no, bh,
2128 last);
2129 brelse(bh);
2130 if (error)
2131 goto out;
2132 index = next_index;
2133 } else
2134 index++;
2135 }
2136
2137 if (index != hsize) {
2138 gfs2_consist_inode(dip);
2139 error = -EIO;
2140 }
2141
2142out:
2143
2144 return error;
2145}
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156int gfs2_diradd_alloc_required(struct inode *inode, const struct qstr *name,
2157 struct gfs2_diradd *da)
2158{
2159 struct gfs2_inode *ip = GFS2_I(inode);
2160 struct gfs2_sbd *sdp = GFS2_SB(inode);
2161 const unsigned int extra = sizeof(struct gfs2_dinode) - sizeof(struct gfs2_leaf);
2162 struct gfs2_dirent *dent;
2163 struct buffer_head *bh;
2164
2165 da->nr_blocks = 0;
2166 da->bh = NULL;
2167 da->dent = NULL;
2168
2169 dent = gfs2_dirent_search(inode, name, gfs2_dirent_find_space, &bh);
2170 if (!dent) {
2171 da->nr_blocks = sdp->sd_max_dirres;
2172 if (!(ip->i_diskflags & GFS2_DIF_EXHASH) &&
2173 (GFS2_DIRENT_SIZE(name->len) < extra))
2174 da->nr_blocks = 1;
2175 return 0;
2176 }
2177 if (IS_ERR(dent))
2178 return PTR_ERR(dent);
2179
2180 if (da->save_loc) {
2181 da->bh = bh;
2182 da->dent = dent;
2183 } else {
2184 brelse(bh);
2185 }
2186 return 0;
2187}
2188
2189