1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * sufile.c - NILFS segment usage file.
4 *
5 * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
6 *
7 * Written by Koji Sato.
8 * Revised by Ryusuke Konishi.
9 */
10
11 #include <linux/kernel.h>
12 #include <linux/fs.h>
13 #include <linux/string.h>
14 #include <linux/buffer_head.h>
15 #include <linux/errno.h>
16 #include "mdt.h"
17 #include "sufile.h"
18
19 #include <trace/events/nilfs2.h>
20
21 /**
22 * struct nilfs_sufile_info - on-memory private data of sufile
23 * @mi: on-memory private data of metadata file
24 * @ncleansegs: number of clean segments
25 * @allocmin: lower limit of allocatable segment range
26 * @allocmax: upper limit of allocatable segment range
27 */
28 struct nilfs_sufile_info {
29 struct nilfs_mdt_info mi;
30 unsigned long ncleansegs;/* number of clean segments */
31 __u64 allocmin; /* lower limit of allocatable segment range */
32 __u64 allocmax; /* upper limit of allocatable segment range */
33 };
34
NILFS_SUI(struct inode * sufile)35 static inline struct nilfs_sufile_info *NILFS_SUI(struct inode *sufile)
36 {
37 return (struct nilfs_sufile_info *)NILFS_MDT(sufile);
38 }
39
40 static inline unsigned long
nilfs_sufile_segment_usages_per_block(const struct inode * sufile)41 nilfs_sufile_segment_usages_per_block(const struct inode *sufile)
42 {
43 return NILFS_MDT(sufile)->mi_entries_per_block;
44 }
45
46 static unsigned long
nilfs_sufile_get_blkoff(const struct inode * sufile,__u64 segnum)47 nilfs_sufile_get_blkoff(const struct inode *sufile, __u64 segnum)
48 {
49 __u64 t = segnum + NILFS_MDT(sufile)->mi_first_entry_offset;
50
51 do_div(t, nilfs_sufile_segment_usages_per_block(sufile));
52 return (unsigned long)t;
53 }
54
55 static unsigned long
nilfs_sufile_get_offset(const struct inode * sufile,__u64 segnum)56 nilfs_sufile_get_offset(const struct inode *sufile, __u64 segnum)
57 {
58 __u64 t = segnum + NILFS_MDT(sufile)->mi_first_entry_offset;
59
60 return do_div(t, nilfs_sufile_segment_usages_per_block(sufile));
61 }
62
63 static unsigned long
nilfs_sufile_segment_usages_in_block(const struct inode * sufile,__u64 curr,__u64 max)64 nilfs_sufile_segment_usages_in_block(const struct inode *sufile, __u64 curr,
65 __u64 max)
66 {
67 return min_t(unsigned long,
68 nilfs_sufile_segment_usages_per_block(sufile) -
69 nilfs_sufile_get_offset(sufile, curr),
70 max - curr + 1);
71 }
72
73 static struct nilfs_segment_usage *
nilfs_sufile_block_get_segment_usage(const struct inode * sufile,__u64 segnum,struct buffer_head * bh,void * kaddr)74 nilfs_sufile_block_get_segment_usage(const struct inode *sufile, __u64 segnum,
75 struct buffer_head *bh, void *kaddr)
76 {
77 return kaddr + bh_offset(bh) +
78 nilfs_sufile_get_offset(sufile, segnum) *
79 NILFS_MDT(sufile)->mi_entry_size;
80 }
81
nilfs_sufile_get_header_block(struct inode * sufile,struct buffer_head ** bhp)82 static inline int nilfs_sufile_get_header_block(struct inode *sufile,
83 struct buffer_head **bhp)
84 {
85 return nilfs_mdt_get_block(sufile, 0, 0, NULL, bhp);
86 }
87
88 static inline int
nilfs_sufile_get_segment_usage_block(struct inode * sufile,__u64 segnum,int create,struct buffer_head ** bhp)89 nilfs_sufile_get_segment_usage_block(struct inode *sufile, __u64 segnum,
90 int create, struct buffer_head **bhp)
91 {
92 return nilfs_mdt_get_block(sufile,
93 nilfs_sufile_get_blkoff(sufile, segnum),
94 create, NULL, bhp);
95 }
96
nilfs_sufile_delete_segment_usage_block(struct inode * sufile,__u64 segnum)97 static int nilfs_sufile_delete_segment_usage_block(struct inode *sufile,
98 __u64 segnum)
99 {
100 return nilfs_mdt_delete_block(sufile,
101 nilfs_sufile_get_blkoff(sufile, segnum));
102 }
103
nilfs_sufile_mod_counter(struct buffer_head * header_bh,u64 ncleanadd,u64 ndirtyadd)104 static void nilfs_sufile_mod_counter(struct buffer_head *header_bh,
105 u64 ncleanadd, u64 ndirtyadd)
106 {
107 struct nilfs_sufile_header *header;
108 void *kaddr;
109
110 kaddr = kmap_atomic(header_bh->b_page);
111 header = kaddr + bh_offset(header_bh);
112 le64_add_cpu(&header->sh_ncleansegs, ncleanadd);
113 le64_add_cpu(&header->sh_ndirtysegs, ndirtyadd);
114 kunmap_atomic(kaddr);
115
116 mark_buffer_dirty(header_bh);
117 }
118
119 /**
120 * nilfs_sufile_get_ncleansegs - return the number of clean segments
121 * @sufile: inode of segment usage file
122 */
nilfs_sufile_get_ncleansegs(struct inode * sufile)123 unsigned long nilfs_sufile_get_ncleansegs(struct inode *sufile)
124 {
125 return NILFS_SUI(sufile)->ncleansegs;
126 }
127
128 /**
129 * nilfs_sufile_updatev - modify multiple segment usages at a time
130 * @sufile: inode of segment usage file
131 * @segnumv: array of segment numbers
132 * @nsegs: size of @segnumv array
133 * @create: creation flag
134 * @ndone: place to store number of modified segments on @segnumv
135 * @dofunc: primitive operation for the update
136 *
137 * Description: nilfs_sufile_updatev() repeatedly calls @dofunc
138 * against the given array of segments. The @dofunc is called with
139 * buffers of a header block and the sufile block in which the target
140 * segment usage entry is contained. If @ndone is given, the number
141 * of successfully modified segments from the head is stored in the
142 * place @ndone points to.
143 *
144 * Return Value: On success, zero is returned. On error, one of the
145 * following negative error codes is returned.
146 *
147 * %-EIO - I/O error.
148 *
149 * %-ENOMEM - Insufficient amount of memory available.
150 *
151 * %-ENOENT - Given segment usage is in hole block (may be returned if
152 * @create is zero)
153 *
154 * %-EINVAL - Invalid segment usage number
155 */
nilfs_sufile_updatev(struct inode * sufile,__u64 * segnumv,size_t nsegs,int create,size_t * ndone,void (* dofunc)(struct inode *,__u64,struct buffer_head *,struct buffer_head *))156 int nilfs_sufile_updatev(struct inode *sufile, __u64 *segnumv, size_t nsegs,
157 int create, size_t *ndone,
158 void (*dofunc)(struct inode *, __u64,
159 struct buffer_head *,
160 struct buffer_head *))
161 {
162 struct buffer_head *header_bh, *bh;
163 unsigned long blkoff, prev_blkoff;
164 __u64 *seg;
165 size_t nerr = 0, n = 0;
166 int ret = 0;
167
168 if (unlikely(nsegs == 0))
169 goto out;
170
171 down_write(&NILFS_MDT(sufile)->mi_sem);
172 for (seg = segnumv; seg < segnumv + nsegs; seg++) {
173 if (unlikely(*seg >= nilfs_sufile_get_nsegments(sufile))) {
174 nilfs_msg(sufile->i_sb, KERN_WARNING,
175 "%s: invalid segment number: %llu",
176 __func__, (unsigned long long)*seg);
177 nerr++;
178 }
179 }
180 if (nerr > 0) {
181 ret = -EINVAL;
182 goto out_sem;
183 }
184
185 ret = nilfs_sufile_get_header_block(sufile, &header_bh);
186 if (ret < 0)
187 goto out_sem;
188
189 seg = segnumv;
190 blkoff = nilfs_sufile_get_blkoff(sufile, *seg);
191 ret = nilfs_mdt_get_block(sufile, blkoff, create, NULL, &bh);
192 if (ret < 0)
193 goto out_header;
194
195 for (;;) {
196 dofunc(sufile, *seg, header_bh, bh);
197
198 if (++seg >= segnumv + nsegs)
199 break;
200 prev_blkoff = blkoff;
201 blkoff = nilfs_sufile_get_blkoff(sufile, *seg);
202 if (blkoff == prev_blkoff)
203 continue;
204
205 /* get different block */
206 brelse(bh);
207 ret = nilfs_mdt_get_block(sufile, blkoff, create, NULL, &bh);
208 if (unlikely(ret < 0))
209 goto out_header;
210 }
211 brelse(bh);
212
213 out_header:
214 n = seg - segnumv;
215 brelse(header_bh);
216 out_sem:
217 up_write(&NILFS_MDT(sufile)->mi_sem);
218 out:
219 if (ndone)
220 *ndone = n;
221 return ret;
222 }
223
nilfs_sufile_update(struct inode * sufile,__u64 segnum,int create,void (* dofunc)(struct inode *,__u64,struct buffer_head *,struct buffer_head *))224 int nilfs_sufile_update(struct inode *sufile, __u64 segnum, int create,
225 void (*dofunc)(struct inode *, __u64,
226 struct buffer_head *,
227 struct buffer_head *))
228 {
229 struct buffer_head *header_bh, *bh;
230 int ret;
231
232 if (unlikely(segnum >= nilfs_sufile_get_nsegments(sufile))) {
233 nilfs_msg(sufile->i_sb, KERN_WARNING,
234 "%s: invalid segment number: %llu",
235 __func__, (unsigned long long)segnum);
236 return -EINVAL;
237 }
238 down_write(&NILFS_MDT(sufile)->mi_sem);
239
240 ret = nilfs_sufile_get_header_block(sufile, &header_bh);
241 if (ret < 0)
242 goto out_sem;
243
244 ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, create, &bh);
245 if (!ret) {
246 dofunc(sufile, segnum, header_bh, bh);
247 brelse(bh);
248 }
249 brelse(header_bh);
250
251 out_sem:
252 up_write(&NILFS_MDT(sufile)->mi_sem);
253 return ret;
254 }
255
256 /**
257 * nilfs_sufile_set_alloc_range - limit range of segment to be allocated
258 * @sufile: inode of segment usage file
259 * @start: minimum segment number of allocatable region (inclusive)
260 * @end: maximum segment number of allocatable region (inclusive)
261 *
262 * Return Value: On success, 0 is returned. On error, one of the
263 * following negative error codes is returned.
264 *
265 * %-ERANGE - invalid segment region
266 */
nilfs_sufile_set_alloc_range(struct inode * sufile,__u64 start,__u64 end)267 int nilfs_sufile_set_alloc_range(struct inode *sufile, __u64 start, __u64 end)
268 {
269 struct nilfs_sufile_info *sui = NILFS_SUI(sufile);
270 __u64 nsegs;
271 int ret = -ERANGE;
272
273 down_write(&NILFS_MDT(sufile)->mi_sem);
274 nsegs = nilfs_sufile_get_nsegments(sufile);
275
276 if (start <= end && end < nsegs) {
277 sui->allocmin = start;
278 sui->allocmax = end;
279 ret = 0;
280 }
281 up_write(&NILFS_MDT(sufile)->mi_sem);
282 return ret;
283 }
284
285 /**
286 * nilfs_sufile_alloc - allocate a segment
287 * @sufile: inode of segment usage file
288 * @segnump: pointer to segment number
289 *
290 * Description: nilfs_sufile_alloc() allocates a clean segment.
291 *
292 * Return Value: On success, 0 is returned and the segment number of the
293 * allocated segment is stored in the place pointed by @segnump. On error, one
294 * of the following negative error codes is returned.
295 *
296 * %-EIO - I/O error.
297 *
298 * %-ENOMEM - Insufficient amount of memory available.
299 *
300 * %-ENOSPC - No clean segment left.
301 */
nilfs_sufile_alloc(struct inode * sufile,__u64 * segnump)302 int nilfs_sufile_alloc(struct inode *sufile, __u64 *segnump)
303 {
304 struct buffer_head *header_bh, *su_bh;
305 struct nilfs_sufile_header *header;
306 struct nilfs_segment_usage *su;
307 struct nilfs_sufile_info *sui = NILFS_SUI(sufile);
308 size_t susz = NILFS_MDT(sufile)->mi_entry_size;
309 __u64 segnum, maxsegnum, last_alloc;
310 void *kaddr;
311 unsigned long nsegments, nsus, cnt;
312 int ret, j;
313
314 down_write(&NILFS_MDT(sufile)->mi_sem);
315
316 ret = nilfs_sufile_get_header_block(sufile, &header_bh);
317 if (ret < 0)
318 goto out_sem;
319 kaddr = kmap_atomic(header_bh->b_page);
320 header = kaddr + bh_offset(header_bh);
321 last_alloc = le64_to_cpu(header->sh_last_alloc);
322 kunmap_atomic(kaddr);
323
324 nsegments = nilfs_sufile_get_nsegments(sufile);
325 maxsegnum = sui->allocmax;
326 segnum = last_alloc + 1;
327 if (segnum < sui->allocmin || segnum > sui->allocmax)
328 segnum = sui->allocmin;
329
330 for (cnt = 0; cnt < nsegments; cnt += nsus) {
331 if (segnum > maxsegnum) {
332 if (cnt < sui->allocmax - sui->allocmin + 1) {
333 /*
334 * wrap around in the limited region.
335 * if allocation started from
336 * sui->allocmin, this never happens.
337 */
338 segnum = sui->allocmin;
339 maxsegnum = last_alloc;
340 } else if (segnum > sui->allocmin &&
341 sui->allocmax + 1 < nsegments) {
342 segnum = sui->allocmax + 1;
343 maxsegnum = nsegments - 1;
344 } else if (sui->allocmin > 0) {
345 segnum = 0;
346 maxsegnum = sui->allocmin - 1;
347 } else {
348 break; /* never happens */
349 }
350 }
351 trace_nilfs2_segment_usage_check(sufile, segnum, cnt);
352 ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 1,
353 &su_bh);
354 if (ret < 0)
355 goto out_header;
356 kaddr = kmap_atomic(su_bh->b_page);
357 su = nilfs_sufile_block_get_segment_usage(
358 sufile, segnum, su_bh, kaddr);
359
360 nsus = nilfs_sufile_segment_usages_in_block(
361 sufile, segnum, maxsegnum);
362 for (j = 0; j < nsus; j++, su = (void *)su + susz, segnum++) {
363 if (!nilfs_segment_usage_clean(su))
364 continue;
365 /* found a clean segment */
366 nilfs_segment_usage_set_dirty(su);
367 kunmap_atomic(kaddr);
368
369 kaddr = kmap_atomic(header_bh->b_page);
370 header = kaddr + bh_offset(header_bh);
371 le64_add_cpu(&header->sh_ncleansegs, -1);
372 le64_add_cpu(&header->sh_ndirtysegs, 1);
373 header->sh_last_alloc = cpu_to_le64(segnum);
374 kunmap_atomic(kaddr);
375
376 sui->ncleansegs--;
377 mark_buffer_dirty(header_bh);
378 mark_buffer_dirty(su_bh);
379 nilfs_mdt_mark_dirty(sufile);
380 brelse(su_bh);
381 *segnump = segnum;
382
383 trace_nilfs2_segment_usage_allocated(sufile, segnum);
384
385 goto out_header;
386 }
387
388 kunmap_atomic(kaddr);
389 brelse(su_bh);
390 }
391
392 /* no segments left */
393 ret = -ENOSPC;
394
395 out_header:
396 brelse(header_bh);
397
398 out_sem:
399 up_write(&NILFS_MDT(sufile)->mi_sem);
400 return ret;
401 }
402
nilfs_sufile_do_cancel_free(struct inode * sufile,__u64 segnum,struct buffer_head * header_bh,struct buffer_head * su_bh)403 void nilfs_sufile_do_cancel_free(struct inode *sufile, __u64 segnum,
404 struct buffer_head *header_bh,
405 struct buffer_head *su_bh)
406 {
407 struct nilfs_segment_usage *su;
408 void *kaddr;
409
410 kaddr = kmap_atomic(su_bh->b_page);
411 su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
412 if (unlikely(!nilfs_segment_usage_clean(su))) {
413 nilfs_msg(sufile->i_sb, KERN_WARNING,
414 "%s: segment %llu must be clean", __func__,
415 (unsigned long long)segnum);
416 kunmap_atomic(kaddr);
417 return;
418 }
419 nilfs_segment_usage_set_dirty(su);
420 kunmap_atomic(kaddr);
421
422 nilfs_sufile_mod_counter(header_bh, -1, 1);
423 NILFS_SUI(sufile)->ncleansegs--;
424
425 mark_buffer_dirty(su_bh);
426 nilfs_mdt_mark_dirty(sufile);
427 }
428
nilfs_sufile_do_scrap(struct inode * sufile,__u64 segnum,struct buffer_head * header_bh,struct buffer_head * su_bh)429 void nilfs_sufile_do_scrap(struct inode *sufile, __u64 segnum,
430 struct buffer_head *header_bh,
431 struct buffer_head *su_bh)
432 {
433 struct nilfs_segment_usage *su;
434 void *kaddr;
435 int clean, dirty;
436
437 kaddr = kmap_atomic(su_bh->b_page);
438 su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
439 if (su->su_flags == cpu_to_le32(BIT(NILFS_SEGMENT_USAGE_DIRTY)) &&
440 su->su_nblocks == cpu_to_le32(0)) {
441 kunmap_atomic(kaddr);
442 return;
443 }
444 clean = nilfs_segment_usage_clean(su);
445 dirty = nilfs_segment_usage_dirty(su);
446
447 /* make the segment garbage */
448 su->su_lastmod = cpu_to_le64(0);
449 su->su_nblocks = cpu_to_le32(0);
450 su->su_flags = cpu_to_le32(BIT(NILFS_SEGMENT_USAGE_DIRTY));
451 kunmap_atomic(kaddr);
452
453 nilfs_sufile_mod_counter(header_bh, clean ? (u64)-1 : 0, dirty ? 0 : 1);
454 NILFS_SUI(sufile)->ncleansegs -= clean;
455
456 mark_buffer_dirty(su_bh);
457 nilfs_mdt_mark_dirty(sufile);
458 }
459
nilfs_sufile_do_free(struct inode * sufile,__u64 segnum,struct buffer_head * header_bh,struct buffer_head * su_bh)460 void nilfs_sufile_do_free(struct inode *sufile, __u64 segnum,
461 struct buffer_head *header_bh,
462 struct buffer_head *su_bh)
463 {
464 struct nilfs_segment_usage *su;
465 void *kaddr;
466 int sudirty;
467
468 kaddr = kmap_atomic(su_bh->b_page);
469 su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
470 if (nilfs_segment_usage_clean(su)) {
471 nilfs_msg(sufile->i_sb, KERN_WARNING,
472 "%s: segment %llu is already clean",
473 __func__, (unsigned long long)segnum);
474 kunmap_atomic(kaddr);
475 return;
476 }
477 WARN_ON(nilfs_segment_usage_error(su));
478 WARN_ON(!nilfs_segment_usage_dirty(su));
479
480 sudirty = nilfs_segment_usage_dirty(su);
481 nilfs_segment_usage_set_clean(su);
482 kunmap_atomic(kaddr);
483 mark_buffer_dirty(su_bh);
484
485 nilfs_sufile_mod_counter(header_bh, 1, sudirty ? (u64)-1 : 0);
486 NILFS_SUI(sufile)->ncleansegs++;
487
488 nilfs_mdt_mark_dirty(sufile);
489
490 trace_nilfs2_segment_usage_freed(sufile, segnum);
491 }
492
493 /**
494 * nilfs_sufile_mark_dirty - mark the buffer having a segment usage dirty
495 * @sufile: inode of segment usage file
496 * @segnum: segment number
497 */
nilfs_sufile_mark_dirty(struct inode * sufile,__u64 segnum)498 int nilfs_sufile_mark_dirty(struct inode *sufile, __u64 segnum)
499 {
500 struct buffer_head *bh;
501 void *kaddr;
502 struct nilfs_segment_usage *su;
503 int ret;
504
505 down_write(&NILFS_MDT(sufile)->mi_sem);
506 ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, &bh);
507 if (!ret) {
508 mark_buffer_dirty(bh);
509 nilfs_mdt_mark_dirty(sufile);
510 kaddr = kmap_atomic(bh->b_page);
511 su = nilfs_sufile_block_get_segment_usage(sufile, segnum, bh, kaddr);
512 nilfs_segment_usage_set_dirty(su);
513 kunmap_atomic(kaddr);
514 brelse(bh);
515 }
516 up_write(&NILFS_MDT(sufile)->mi_sem);
517 return ret;
518 }
519
520 /**
521 * nilfs_sufile_set_segment_usage - set usage of a segment
522 * @sufile: inode of segment usage file
523 * @segnum: segment number
524 * @nblocks: number of live blocks in the segment
525 * @modtime: modification time (option)
526 */
nilfs_sufile_set_segment_usage(struct inode * sufile,__u64 segnum,unsigned long nblocks,time64_t modtime)527 int nilfs_sufile_set_segment_usage(struct inode *sufile, __u64 segnum,
528 unsigned long nblocks, time64_t modtime)
529 {
530 struct buffer_head *bh;
531 struct nilfs_segment_usage *su;
532 void *kaddr;
533 int ret;
534
535 down_write(&NILFS_MDT(sufile)->mi_sem);
536 ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, &bh);
537 if (ret < 0)
538 goto out_sem;
539
540 kaddr = kmap_atomic(bh->b_page);
541 su = nilfs_sufile_block_get_segment_usage(sufile, segnum, bh, kaddr);
542 WARN_ON(nilfs_segment_usage_error(su));
543 if (modtime)
544 su->su_lastmod = cpu_to_le64(modtime);
545 su->su_nblocks = cpu_to_le32(nblocks);
546 kunmap_atomic(kaddr);
547
548 mark_buffer_dirty(bh);
549 nilfs_mdt_mark_dirty(sufile);
550 brelse(bh);
551
552 out_sem:
553 up_write(&NILFS_MDT(sufile)->mi_sem);
554 return ret;
555 }
556
557 /**
558 * nilfs_sufile_get_stat - get segment usage statistics
559 * @sufile: inode of segment usage file
560 * @stat: pointer to a structure of segment usage statistics
561 *
562 * Description: nilfs_sufile_get_stat() returns information about segment
563 * usage.
564 *
565 * Return Value: On success, 0 is returned, and segment usage information is
566 * stored in the place pointed by @stat. On error, one of the following
567 * negative error codes is returned.
568 *
569 * %-EIO - I/O error.
570 *
571 * %-ENOMEM - Insufficient amount of memory available.
572 */
nilfs_sufile_get_stat(struct inode * sufile,struct nilfs_sustat * sustat)573 int nilfs_sufile_get_stat(struct inode *sufile, struct nilfs_sustat *sustat)
574 {
575 struct buffer_head *header_bh;
576 struct nilfs_sufile_header *header;
577 struct the_nilfs *nilfs = sufile->i_sb->s_fs_info;
578 void *kaddr;
579 int ret;
580
581 down_read(&NILFS_MDT(sufile)->mi_sem);
582
583 ret = nilfs_sufile_get_header_block(sufile, &header_bh);
584 if (ret < 0)
585 goto out_sem;
586
587 kaddr = kmap_atomic(header_bh->b_page);
588 header = kaddr + bh_offset(header_bh);
589 sustat->ss_nsegs = nilfs_sufile_get_nsegments(sufile);
590 sustat->ss_ncleansegs = le64_to_cpu(header->sh_ncleansegs);
591 sustat->ss_ndirtysegs = le64_to_cpu(header->sh_ndirtysegs);
592 sustat->ss_ctime = nilfs->ns_ctime;
593 sustat->ss_nongc_ctime = nilfs->ns_nongc_ctime;
594 spin_lock(&nilfs->ns_last_segment_lock);
595 sustat->ss_prot_seq = nilfs->ns_prot_seq;
596 spin_unlock(&nilfs->ns_last_segment_lock);
597 kunmap_atomic(kaddr);
598 brelse(header_bh);
599
600 out_sem:
601 up_read(&NILFS_MDT(sufile)->mi_sem);
602 return ret;
603 }
604
nilfs_sufile_do_set_error(struct inode * sufile,__u64 segnum,struct buffer_head * header_bh,struct buffer_head * su_bh)605 void nilfs_sufile_do_set_error(struct inode *sufile, __u64 segnum,
606 struct buffer_head *header_bh,
607 struct buffer_head *su_bh)
608 {
609 struct nilfs_segment_usage *su;
610 void *kaddr;
611 int suclean;
612
613 kaddr = kmap_atomic(su_bh->b_page);
614 su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
615 if (nilfs_segment_usage_error(su)) {
616 kunmap_atomic(kaddr);
617 return;
618 }
619 suclean = nilfs_segment_usage_clean(su);
620 nilfs_segment_usage_set_error(su);
621 kunmap_atomic(kaddr);
622
623 if (suclean) {
624 nilfs_sufile_mod_counter(header_bh, -1, 0);
625 NILFS_SUI(sufile)->ncleansegs--;
626 }
627 mark_buffer_dirty(su_bh);
628 nilfs_mdt_mark_dirty(sufile);
629 }
630
631 /**
632 * nilfs_sufile_truncate_range - truncate range of segment array
633 * @sufile: inode of segment usage file
634 * @start: start segment number (inclusive)
635 * @end: end segment number (inclusive)
636 *
637 * Return Value: On success, 0 is returned. On error, one of the
638 * following negative error codes is returned.
639 *
640 * %-EIO - I/O error.
641 *
642 * %-ENOMEM - Insufficient amount of memory available.
643 *
644 * %-EINVAL - Invalid number of segments specified
645 *
646 * %-EBUSY - Dirty or active segments are present in the range
647 */
nilfs_sufile_truncate_range(struct inode * sufile,__u64 start,__u64 end)648 static int nilfs_sufile_truncate_range(struct inode *sufile,
649 __u64 start, __u64 end)
650 {
651 struct the_nilfs *nilfs = sufile->i_sb->s_fs_info;
652 struct buffer_head *header_bh;
653 struct buffer_head *su_bh;
654 struct nilfs_segment_usage *su, *su2;
655 size_t susz = NILFS_MDT(sufile)->mi_entry_size;
656 unsigned long segusages_per_block;
657 unsigned long nsegs, ncleaned;
658 __u64 segnum;
659 void *kaddr;
660 ssize_t n, nc;
661 int ret;
662 int j;
663
664 nsegs = nilfs_sufile_get_nsegments(sufile);
665
666 ret = -EINVAL;
667 if (start > end || start >= nsegs)
668 goto out;
669
670 ret = nilfs_sufile_get_header_block(sufile, &header_bh);
671 if (ret < 0)
672 goto out;
673
674 segusages_per_block = nilfs_sufile_segment_usages_per_block(sufile);
675 ncleaned = 0;
676
677 for (segnum = start; segnum <= end; segnum += n) {
678 n = min_t(unsigned long,
679 segusages_per_block -
680 nilfs_sufile_get_offset(sufile, segnum),
681 end - segnum + 1);
682 ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0,
683 &su_bh);
684 if (ret < 0) {
685 if (ret != -ENOENT)
686 goto out_header;
687 /* hole */
688 continue;
689 }
690 kaddr = kmap_atomic(su_bh->b_page);
691 su = nilfs_sufile_block_get_segment_usage(
692 sufile, segnum, su_bh, kaddr);
693 su2 = su;
694 for (j = 0; j < n; j++, su = (void *)su + susz) {
695 if ((le32_to_cpu(su->su_flags) &
696 ~BIT(NILFS_SEGMENT_USAGE_ERROR)) ||
697 nilfs_segment_is_active(nilfs, segnum + j)) {
698 ret = -EBUSY;
699 kunmap_atomic(kaddr);
700 brelse(su_bh);
701 goto out_header;
702 }
703 }
704 nc = 0;
705 for (su = su2, j = 0; j < n; j++, su = (void *)su + susz) {
706 if (nilfs_segment_usage_error(su)) {
707 nilfs_segment_usage_set_clean(su);
708 nc++;
709 }
710 }
711 kunmap_atomic(kaddr);
712 if (nc > 0) {
713 mark_buffer_dirty(su_bh);
714 ncleaned += nc;
715 }
716 brelse(su_bh);
717
718 if (n == segusages_per_block) {
719 /* make hole */
720 nilfs_sufile_delete_segment_usage_block(sufile, segnum);
721 }
722 }
723 ret = 0;
724
725 out_header:
726 if (ncleaned > 0) {
727 NILFS_SUI(sufile)->ncleansegs += ncleaned;
728 nilfs_sufile_mod_counter(header_bh, ncleaned, 0);
729 nilfs_mdt_mark_dirty(sufile);
730 }
731 brelse(header_bh);
732 out:
733 return ret;
734 }
735
736 /**
737 * nilfs_sufile_resize - resize segment array
738 * @sufile: inode of segment usage file
739 * @newnsegs: new number of segments
740 *
741 * Return Value: On success, 0 is returned. On error, one of the
742 * following negative error codes is returned.
743 *
744 * %-EIO - I/O error.
745 *
746 * %-ENOMEM - Insufficient amount of memory available.
747 *
748 * %-ENOSPC - Enough free space is not left for shrinking
749 *
750 * %-EBUSY - Dirty or active segments exist in the region to be truncated
751 */
nilfs_sufile_resize(struct inode * sufile,__u64 newnsegs)752 int nilfs_sufile_resize(struct inode *sufile, __u64 newnsegs)
753 {
754 struct the_nilfs *nilfs = sufile->i_sb->s_fs_info;
755 struct buffer_head *header_bh;
756 struct nilfs_sufile_header *header;
757 struct nilfs_sufile_info *sui = NILFS_SUI(sufile);
758 void *kaddr;
759 unsigned long nsegs, nrsvsegs;
760 int ret = 0;
761
762 down_write(&NILFS_MDT(sufile)->mi_sem);
763
764 nsegs = nilfs_sufile_get_nsegments(sufile);
765 if (nsegs == newnsegs)
766 goto out;
767
768 ret = -ENOSPC;
769 nrsvsegs = nilfs_nrsvsegs(nilfs, newnsegs);
770 if (newnsegs < nsegs && nsegs - newnsegs + nrsvsegs > sui->ncleansegs)
771 goto out;
772
773 ret = nilfs_sufile_get_header_block(sufile, &header_bh);
774 if (ret < 0)
775 goto out;
776
777 if (newnsegs > nsegs) {
778 sui->ncleansegs += newnsegs - nsegs;
779 } else /* newnsegs < nsegs */ {
780 ret = nilfs_sufile_truncate_range(sufile, newnsegs, nsegs - 1);
781 if (ret < 0)
782 goto out_header;
783
784 sui->ncleansegs -= nsegs - newnsegs;
785
786 /*
787 * If the sufile is successfully truncated, immediately adjust
788 * the segment allocation space while locking the semaphore
789 * "mi_sem" so that nilfs_sufile_alloc() never allocates
790 * segments in the truncated space.
791 */
792 sui->allocmax = newnsegs - 1;
793 sui->allocmin = 0;
794 }
795
796 kaddr = kmap_atomic(header_bh->b_page);
797 header = kaddr + bh_offset(header_bh);
798 header->sh_ncleansegs = cpu_to_le64(sui->ncleansegs);
799 kunmap_atomic(kaddr);
800
801 mark_buffer_dirty(header_bh);
802 nilfs_mdt_mark_dirty(sufile);
803 nilfs_set_nsegments(nilfs, newnsegs);
804
805 out_header:
806 brelse(header_bh);
807 out:
808 up_write(&NILFS_MDT(sufile)->mi_sem);
809 return ret;
810 }
811
812 /**
813 * nilfs_sufile_get_suinfo -
814 * @sufile: inode of segment usage file
815 * @segnum: segment number to start looking
816 * @buf: array of suinfo
817 * @sisz: byte size of suinfo
818 * @nsi: size of suinfo array
819 *
820 * Description:
821 *
822 * Return Value: On success, 0 is returned and .... On error, one of the
823 * following negative error codes is returned.
824 *
825 * %-EIO - I/O error.
826 *
827 * %-ENOMEM - Insufficient amount of memory available.
828 */
nilfs_sufile_get_suinfo(struct inode * sufile,__u64 segnum,void * buf,unsigned int sisz,size_t nsi)829 ssize_t nilfs_sufile_get_suinfo(struct inode *sufile, __u64 segnum, void *buf,
830 unsigned int sisz, size_t nsi)
831 {
832 struct buffer_head *su_bh;
833 struct nilfs_segment_usage *su;
834 struct nilfs_suinfo *si = buf;
835 size_t susz = NILFS_MDT(sufile)->mi_entry_size;
836 struct the_nilfs *nilfs = sufile->i_sb->s_fs_info;
837 void *kaddr;
838 unsigned long nsegs, segusages_per_block;
839 ssize_t n;
840 int ret, i, j;
841
842 down_read(&NILFS_MDT(sufile)->mi_sem);
843
844 segusages_per_block = nilfs_sufile_segment_usages_per_block(sufile);
845 nsegs = min_t(unsigned long,
846 nilfs_sufile_get_nsegments(sufile) - segnum,
847 nsi);
848 for (i = 0; i < nsegs; i += n, segnum += n) {
849 n = min_t(unsigned long,
850 segusages_per_block -
851 nilfs_sufile_get_offset(sufile, segnum),
852 nsegs - i);
853 ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0,
854 &su_bh);
855 if (ret < 0) {
856 if (ret != -ENOENT)
857 goto out;
858 /* hole */
859 memset(si, 0, sisz * n);
860 si = (void *)si + sisz * n;
861 continue;
862 }
863
864 kaddr = kmap_atomic(su_bh->b_page);
865 su = nilfs_sufile_block_get_segment_usage(
866 sufile, segnum, su_bh, kaddr);
867 for (j = 0; j < n;
868 j++, su = (void *)su + susz, si = (void *)si + sisz) {
869 si->sui_lastmod = le64_to_cpu(su->su_lastmod);
870 si->sui_nblocks = le32_to_cpu(su->su_nblocks);
871 si->sui_flags = le32_to_cpu(su->su_flags) &
872 ~BIT(NILFS_SEGMENT_USAGE_ACTIVE);
873 if (nilfs_segment_is_active(nilfs, segnum + j))
874 si->sui_flags |=
875 BIT(NILFS_SEGMENT_USAGE_ACTIVE);
876 }
877 kunmap_atomic(kaddr);
878 brelse(su_bh);
879 }
880 ret = nsegs;
881
882 out:
883 up_read(&NILFS_MDT(sufile)->mi_sem);
884 return ret;
885 }
886
887 /**
888 * nilfs_sufile_set_suinfo - sets segment usage info
889 * @sufile: inode of segment usage file
890 * @buf: array of suinfo_update
891 * @supsz: byte size of suinfo_update
892 * @nsup: size of suinfo_update array
893 *
894 * Description: Takes an array of nilfs_suinfo_update structs and updates
895 * segment usage accordingly. Only the fields indicated by the sup_flags
896 * are updated.
897 *
898 * Return Value: On success, 0 is returned. On error, one of the
899 * following negative error codes is returned.
900 *
901 * %-EIO - I/O error.
902 *
903 * %-ENOMEM - Insufficient amount of memory available.
904 *
905 * %-EINVAL - Invalid values in input (segment number, flags or nblocks)
906 */
nilfs_sufile_set_suinfo(struct inode * sufile,void * buf,unsigned int supsz,size_t nsup)907 ssize_t nilfs_sufile_set_suinfo(struct inode *sufile, void *buf,
908 unsigned int supsz, size_t nsup)
909 {
910 struct the_nilfs *nilfs = sufile->i_sb->s_fs_info;
911 struct buffer_head *header_bh, *bh;
912 struct nilfs_suinfo_update *sup, *supend = buf + supsz * nsup;
913 struct nilfs_segment_usage *su;
914 void *kaddr;
915 unsigned long blkoff, prev_blkoff;
916 int cleansi, cleansu, dirtysi, dirtysu;
917 long ncleaned = 0, ndirtied = 0;
918 int ret = 0;
919
920 if (unlikely(nsup == 0))
921 return ret;
922
923 for (sup = buf; sup < supend; sup = (void *)sup + supsz) {
924 if (sup->sup_segnum >= nilfs->ns_nsegments
925 || (sup->sup_flags &
926 (~0UL << __NR_NILFS_SUINFO_UPDATE_FIELDS))
927 || (nilfs_suinfo_update_nblocks(sup) &&
928 sup->sup_sui.sui_nblocks >
929 nilfs->ns_blocks_per_segment))
930 return -EINVAL;
931 }
932
933 down_write(&NILFS_MDT(sufile)->mi_sem);
934
935 ret = nilfs_sufile_get_header_block(sufile, &header_bh);
936 if (ret < 0)
937 goto out_sem;
938
939 sup = buf;
940 blkoff = nilfs_sufile_get_blkoff(sufile, sup->sup_segnum);
941 ret = nilfs_mdt_get_block(sufile, blkoff, 1, NULL, &bh);
942 if (ret < 0)
943 goto out_header;
944
945 for (;;) {
946 kaddr = kmap_atomic(bh->b_page);
947 su = nilfs_sufile_block_get_segment_usage(
948 sufile, sup->sup_segnum, bh, kaddr);
949
950 if (nilfs_suinfo_update_lastmod(sup))
951 su->su_lastmod = cpu_to_le64(sup->sup_sui.sui_lastmod);
952
953 if (nilfs_suinfo_update_nblocks(sup))
954 su->su_nblocks = cpu_to_le32(sup->sup_sui.sui_nblocks);
955
956 if (nilfs_suinfo_update_flags(sup)) {
957 /*
958 * Active flag is a virtual flag projected by running
959 * nilfs kernel code - drop it not to write it to
960 * disk.
961 */
962 sup->sup_sui.sui_flags &=
963 ~BIT(NILFS_SEGMENT_USAGE_ACTIVE);
964
965 cleansi = nilfs_suinfo_clean(&sup->sup_sui);
966 cleansu = nilfs_segment_usage_clean(su);
967 dirtysi = nilfs_suinfo_dirty(&sup->sup_sui);
968 dirtysu = nilfs_segment_usage_dirty(su);
969
970 if (cleansi && !cleansu)
971 ++ncleaned;
972 else if (!cleansi && cleansu)
973 --ncleaned;
974
975 if (dirtysi && !dirtysu)
976 ++ndirtied;
977 else if (!dirtysi && dirtysu)
978 --ndirtied;
979
980 su->su_flags = cpu_to_le32(sup->sup_sui.sui_flags);
981 }
982
983 kunmap_atomic(kaddr);
984
985 sup = (void *)sup + supsz;
986 if (sup >= supend)
987 break;
988
989 prev_blkoff = blkoff;
990 blkoff = nilfs_sufile_get_blkoff(sufile, sup->sup_segnum);
991 if (blkoff == prev_blkoff)
992 continue;
993
994 /* get different block */
995 mark_buffer_dirty(bh);
996 put_bh(bh);
997 ret = nilfs_mdt_get_block(sufile, blkoff, 1, NULL, &bh);
998 if (unlikely(ret < 0))
999 goto out_mark;
1000 }
1001 mark_buffer_dirty(bh);
1002 put_bh(bh);
1003
1004 out_mark:
1005 if (ncleaned || ndirtied) {
1006 nilfs_sufile_mod_counter(header_bh, (u64)ncleaned,
1007 (u64)ndirtied);
1008 NILFS_SUI(sufile)->ncleansegs += ncleaned;
1009 }
1010 nilfs_mdt_mark_dirty(sufile);
1011 out_header:
1012 put_bh(header_bh);
1013 out_sem:
1014 up_write(&NILFS_MDT(sufile)->mi_sem);
1015 return ret;
1016 }
1017
1018 /**
1019 * nilfs_sufile_trim_fs() - trim ioctl handle function
1020 * @sufile: inode of segment usage file
1021 * @range: fstrim_range structure
1022 *
1023 * start: First Byte to trim
1024 * len: number of Bytes to trim from start
1025 * minlen: minimum extent length in Bytes
1026 *
1027 * Decription: nilfs_sufile_trim_fs goes through all segments containing bytes
1028 * from start to start+len. start is rounded up to the next block boundary
1029 * and start+len is rounded down. For each clean segment blkdev_issue_discard
1030 * function is invoked.
1031 *
1032 * Return Value: On success, 0 is returned or negative error code, otherwise.
1033 */
nilfs_sufile_trim_fs(struct inode * sufile,struct fstrim_range * range)1034 int nilfs_sufile_trim_fs(struct inode *sufile, struct fstrim_range *range)
1035 {
1036 struct the_nilfs *nilfs = sufile->i_sb->s_fs_info;
1037 struct buffer_head *su_bh;
1038 struct nilfs_segment_usage *su;
1039 void *kaddr;
1040 size_t n, i, susz = NILFS_MDT(sufile)->mi_entry_size;
1041 sector_t seg_start, seg_end, start_block, end_block;
1042 sector_t start = 0, nblocks = 0;
1043 u64 segnum, segnum_end, minlen, len, max_blocks, ndiscarded = 0;
1044 int ret = 0;
1045 unsigned int sects_per_block;
1046
1047 sects_per_block = (1 << nilfs->ns_blocksize_bits) /
1048 bdev_logical_block_size(nilfs->ns_bdev);
1049 len = range->len >> nilfs->ns_blocksize_bits;
1050 minlen = range->minlen >> nilfs->ns_blocksize_bits;
1051 max_blocks = ((u64)nilfs->ns_nsegments * nilfs->ns_blocks_per_segment);
1052
1053 if (!len || range->start >= max_blocks << nilfs->ns_blocksize_bits)
1054 return -EINVAL;
1055
1056 start_block = (range->start + nilfs->ns_blocksize - 1) >>
1057 nilfs->ns_blocksize_bits;
1058
1059 /*
1060 * range->len can be very large (actually, it is set to
1061 * ULLONG_MAX by default) - truncate upper end of the range
1062 * carefully so as not to overflow.
1063 */
1064 if (max_blocks - start_block < len)
1065 end_block = max_blocks - 1;
1066 else
1067 end_block = start_block + len - 1;
1068
1069 segnum = nilfs_get_segnum_of_block(nilfs, start_block);
1070 segnum_end = nilfs_get_segnum_of_block(nilfs, end_block);
1071
1072 down_read(&NILFS_MDT(sufile)->mi_sem);
1073
1074 while (segnum <= segnum_end) {
1075 n = nilfs_sufile_segment_usages_in_block(sufile, segnum,
1076 segnum_end);
1077
1078 ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0,
1079 &su_bh);
1080 if (ret < 0) {
1081 if (ret != -ENOENT)
1082 goto out_sem;
1083 /* hole */
1084 segnum += n;
1085 continue;
1086 }
1087
1088 kaddr = kmap_atomic(su_bh->b_page);
1089 su = nilfs_sufile_block_get_segment_usage(sufile, segnum,
1090 su_bh, kaddr);
1091 for (i = 0; i < n; ++i, ++segnum, su = (void *)su + susz) {
1092 if (!nilfs_segment_usage_clean(su))
1093 continue;
1094
1095 nilfs_get_segment_range(nilfs, segnum, &seg_start,
1096 &seg_end);
1097
1098 if (!nblocks) {
1099 /* start new extent */
1100 start = seg_start;
1101 nblocks = seg_end - seg_start + 1;
1102 continue;
1103 }
1104
1105 if (start + nblocks == seg_start) {
1106 /* add to previous extent */
1107 nblocks += seg_end - seg_start + 1;
1108 continue;
1109 }
1110
1111 /* discard previous extent */
1112 if (start < start_block) {
1113 nblocks -= start_block - start;
1114 start = start_block;
1115 }
1116
1117 if (nblocks >= minlen) {
1118 kunmap_atomic(kaddr);
1119
1120 ret = blkdev_issue_discard(nilfs->ns_bdev,
1121 start * sects_per_block,
1122 nblocks * sects_per_block,
1123 GFP_NOFS, 0);
1124 if (ret < 0) {
1125 put_bh(su_bh);
1126 goto out_sem;
1127 }
1128
1129 ndiscarded += nblocks;
1130 kaddr = kmap_atomic(su_bh->b_page);
1131 su = nilfs_sufile_block_get_segment_usage(
1132 sufile, segnum, su_bh, kaddr);
1133 }
1134
1135 /* start new extent */
1136 start = seg_start;
1137 nblocks = seg_end - seg_start + 1;
1138 }
1139 kunmap_atomic(kaddr);
1140 put_bh(su_bh);
1141 }
1142
1143
1144 if (nblocks) {
1145 /* discard last extent */
1146 if (start < start_block) {
1147 nblocks -= start_block - start;
1148 start = start_block;
1149 }
1150 if (start + nblocks > end_block + 1)
1151 nblocks = end_block - start + 1;
1152
1153 if (nblocks >= minlen) {
1154 ret = blkdev_issue_discard(nilfs->ns_bdev,
1155 start * sects_per_block,
1156 nblocks * sects_per_block,
1157 GFP_NOFS, 0);
1158 if (!ret)
1159 ndiscarded += nblocks;
1160 }
1161 }
1162
1163 out_sem:
1164 up_read(&NILFS_MDT(sufile)->mi_sem);
1165
1166 range->len = ndiscarded << nilfs->ns_blocksize_bits;
1167 return ret;
1168 }
1169
1170 /**
1171 * nilfs_sufile_read - read or get sufile inode
1172 * @sb: super block instance
1173 * @susize: size of a segment usage entry
1174 * @raw_inode: on-disk sufile inode
1175 * @inodep: buffer to store the inode
1176 */
nilfs_sufile_read(struct super_block * sb,size_t susize,struct nilfs_inode * raw_inode,struct inode ** inodep)1177 int nilfs_sufile_read(struct super_block *sb, size_t susize,
1178 struct nilfs_inode *raw_inode, struct inode **inodep)
1179 {
1180 struct inode *sufile;
1181 struct nilfs_sufile_info *sui;
1182 struct buffer_head *header_bh;
1183 struct nilfs_sufile_header *header;
1184 void *kaddr;
1185 int err;
1186
1187 if (susize > sb->s_blocksize) {
1188 nilfs_msg(sb, KERN_ERR,
1189 "too large segment usage size: %zu bytes", susize);
1190 return -EINVAL;
1191 } else if (susize < NILFS_MIN_SEGMENT_USAGE_SIZE) {
1192 nilfs_msg(sb, KERN_ERR,
1193 "too small segment usage size: %zu bytes", susize);
1194 return -EINVAL;
1195 }
1196
1197 sufile = nilfs_iget_locked(sb, NULL, NILFS_SUFILE_INO);
1198 if (unlikely(!sufile))
1199 return -ENOMEM;
1200 if (!(sufile->i_state & I_NEW))
1201 goto out;
1202
1203 err = nilfs_mdt_init(sufile, NILFS_MDT_GFP, sizeof(*sui));
1204 if (err)
1205 goto failed;
1206
1207 nilfs_mdt_set_entry_size(sufile, susize,
1208 sizeof(struct nilfs_sufile_header));
1209
1210 err = nilfs_read_inode_common(sufile, raw_inode);
1211 if (err)
1212 goto failed;
1213
1214 err = nilfs_sufile_get_header_block(sufile, &header_bh);
1215 if (err)
1216 goto failed;
1217
1218 sui = NILFS_SUI(sufile);
1219 kaddr = kmap_atomic(header_bh->b_page);
1220 header = kaddr + bh_offset(header_bh);
1221 sui->ncleansegs = le64_to_cpu(header->sh_ncleansegs);
1222 kunmap_atomic(kaddr);
1223 brelse(header_bh);
1224
1225 sui->allocmax = nilfs_sufile_get_nsegments(sufile) - 1;
1226 sui->allocmin = 0;
1227
1228 unlock_new_inode(sufile);
1229 out:
1230 *inodep = sufile;
1231 return 0;
1232 failed:
1233 iget_failed(sufile);
1234 return err;
1235 }
1236