GNU Linux-libre 4.19.211-gnu1
[releases.git] / fs / nilfs2 / dat.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * dat.c - NILFS disk address translation.
4  *
5  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
6  *
7  * Written by Koji Sato.
8  */
9
10 #include <linux/types.h>
11 #include <linux/buffer_head.h>
12 #include <linux/string.h>
13 #include <linux/errno.h>
14 #include "nilfs.h"
15 #include "mdt.h"
16 #include "alloc.h"
17 #include "dat.h"
18
19
20 #define NILFS_CNO_MIN   ((__u64)1)
21 #define NILFS_CNO_MAX   (~(__u64)0)
22
23 /**
24  * struct nilfs_dat_info - on-memory private data of DAT file
25  * @mi: on-memory private data of metadata file
26  * @palloc_cache: persistent object allocator cache of DAT file
27  * @shadow: shadow map of DAT file
28  */
29 struct nilfs_dat_info {
30         struct nilfs_mdt_info mi;
31         struct nilfs_palloc_cache palloc_cache;
32         struct nilfs_shadow_map shadow;
33 };
34
35 static inline struct nilfs_dat_info *NILFS_DAT_I(struct inode *dat)
36 {
37         return (struct nilfs_dat_info *)NILFS_MDT(dat);
38 }
39
40 static int nilfs_dat_prepare_entry(struct inode *dat,
41                                    struct nilfs_palloc_req *req, int create)
42 {
43         return nilfs_palloc_get_entry_block(dat, req->pr_entry_nr,
44                                             create, &req->pr_entry_bh);
45 }
46
47 static void nilfs_dat_commit_entry(struct inode *dat,
48                                    struct nilfs_palloc_req *req)
49 {
50         mark_buffer_dirty(req->pr_entry_bh);
51         nilfs_mdt_mark_dirty(dat);
52         brelse(req->pr_entry_bh);
53 }
54
55 static void nilfs_dat_abort_entry(struct inode *dat,
56                                   struct nilfs_palloc_req *req)
57 {
58         brelse(req->pr_entry_bh);
59 }
60
61 int nilfs_dat_prepare_alloc(struct inode *dat, struct nilfs_palloc_req *req)
62 {
63         int ret;
64
65         ret = nilfs_palloc_prepare_alloc_entry(dat, req);
66         if (ret < 0)
67                 return ret;
68
69         ret = nilfs_dat_prepare_entry(dat, req, 1);
70         if (ret < 0)
71                 nilfs_palloc_abort_alloc_entry(dat, req);
72
73         return ret;
74 }
75
76 void nilfs_dat_commit_alloc(struct inode *dat, struct nilfs_palloc_req *req)
77 {
78         struct nilfs_dat_entry *entry;
79         void *kaddr;
80
81         kaddr = kmap_atomic(req->pr_entry_bh->b_page);
82         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
83                                              req->pr_entry_bh, kaddr);
84         entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
85         entry->de_end = cpu_to_le64(NILFS_CNO_MAX);
86         entry->de_blocknr = cpu_to_le64(0);
87         kunmap_atomic(kaddr);
88
89         nilfs_palloc_commit_alloc_entry(dat, req);
90         nilfs_dat_commit_entry(dat, req);
91 }
92
93 void nilfs_dat_abort_alloc(struct inode *dat, struct nilfs_palloc_req *req)
94 {
95         nilfs_dat_abort_entry(dat, req);
96         nilfs_palloc_abort_alloc_entry(dat, req);
97 }
98
99 static void nilfs_dat_commit_free(struct inode *dat,
100                                   struct nilfs_palloc_req *req)
101 {
102         struct nilfs_dat_entry *entry;
103         void *kaddr;
104
105         kaddr = kmap_atomic(req->pr_entry_bh->b_page);
106         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
107                                              req->pr_entry_bh, kaddr);
108         entry->de_start = cpu_to_le64(NILFS_CNO_MIN);
109         entry->de_end = cpu_to_le64(NILFS_CNO_MIN);
110         entry->de_blocknr = cpu_to_le64(0);
111         kunmap_atomic(kaddr);
112
113         nilfs_dat_commit_entry(dat, req);
114         nilfs_palloc_commit_free_entry(dat, req);
115 }
116
117 int nilfs_dat_prepare_start(struct inode *dat, struct nilfs_palloc_req *req)
118 {
119         int ret;
120
121         ret = nilfs_dat_prepare_entry(dat, req, 0);
122         WARN_ON(ret == -ENOENT);
123         return ret;
124 }
125
126 void nilfs_dat_commit_start(struct inode *dat, struct nilfs_palloc_req *req,
127                             sector_t blocknr)
128 {
129         struct nilfs_dat_entry *entry;
130         void *kaddr;
131
132         kaddr = kmap_atomic(req->pr_entry_bh->b_page);
133         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
134                                              req->pr_entry_bh, kaddr);
135         entry->de_start = cpu_to_le64(nilfs_mdt_cno(dat));
136         entry->de_blocknr = cpu_to_le64(blocknr);
137         kunmap_atomic(kaddr);
138
139         nilfs_dat_commit_entry(dat, req);
140 }
141
142 int nilfs_dat_prepare_end(struct inode *dat, struct nilfs_palloc_req *req)
143 {
144         struct nilfs_dat_entry *entry;
145         sector_t blocknr;
146         void *kaddr;
147         int ret;
148
149         ret = nilfs_dat_prepare_entry(dat, req, 0);
150         if (ret < 0) {
151                 WARN_ON(ret == -ENOENT);
152                 return ret;
153         }
154
155         kaddr = kmap_atomic(req->pr_entry_bh->b_page);
156         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
157                                              req->pr_entry_bh, kaddr);
158         blocknr = le64_to_cpu(entry->de_blocknr);
159         kunmap_atomic(kaddr);
160
161         if (blocknr == 0) {
162                 ret = nilfs_palloc_prepare_free_entry(dat, req);
163                 if (ret < 0) {
164                         nilfs_dat_abort_entry(dat, req);
165                         return ret;
166                 }
167         }
168
169         return 0;
170 }
171
172 void nilfs_dat_commit_end(struct inode *dat, struct nilfs_palloc_req *req,
173                           int dead)
174 {
175         struct nilfs_dat_entry *entry;
176         __u64 start, end;
177         sector_t blocknr;
178         void *kaddr;
179
180         kaddr = kmap_atomic(req->pr_entry_bh->b_page);
181         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
182                                              req->pr_entry_bh, kaddr);
183         end = start = le64_to_cpu(entry->de_start);
184         if (!dead) {
185                 end = nilfs_mdt_cno(dat);
186                 WARN_ON(start > end);
187         }
188         entry->de_end = cpu_to_le64(end);
189         blocknr = le64_to_cpu(entry->de_blocknr);
190         kunmap_atomic(kaddr);
191
192         if (blocknr == 0)
193                 nilfs_dat_commit_free(dat, req);
194         else
195                 nilfs_dat_commit_entry(dat, req);
196 }
197
198 void nilfs_dat_abort_end(struct inode *dat, struct nilfs_palloc_req *req)
199 {
200         struct nilfs_dat_entry *entry;
201         __u64 start;
202         sector_t blocknr;
203         void *kaddr;
204
205         kaddr = kmap_atomic(req->pr_entry_bh->b_page);
206         entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
207                                              req->pr_entry_bh, kaddr);
208         start = le64_to_cpu(entry->de_start);
209         blocknr = le64_to_cpu(entry->de_blocknr);
210         kunmap_atomic(kaddr);
211
212         if (start == nilfs_mdt_cno(dat) && blocknr == 0)
213                 nilfs_palloc_abort_free_entry(dat, req);
214         nilfs_dat_abort_entry(dat, req);
215 }
216
217 int nilfs_dat_prepare_update(struct inode *dat,
218                              struct nilfs_palloc_req *oldreq,
219                              struct nilfs_palloc_req *newreq)
220 {
221         int ret;
222
223         ret = nilfs_dat_prepare_end(dat, oldreq);
224         if (!ret) {
225                 ret = nilfs_dat_prepare_alloc(dat, newreq);
226                 if (ret < 0)
227                         nilfs_dat_abort_end(dat, oldreq);
228         }
229         return ret;
230 }
231
232 void nilfs_dat_commit_update(struct inode *dat,
233                              struct nilfs_palloc_req *oldreq,
234                              struct nilfs_palloc_req *newreq, int dead)
235 {
236         nilfs_dat_commit_end(dat, oldreq, dead);
237         nilfs_dat_commit_alloc(dat, newreq);
238 }
239
240 void nilfs_dat_abort_update(struct inode *dat,
241                             struct nilfs_palloc_req *oldreq,
242                             struct nilfs_palloc_req *newreq)
243 {
244         nilfs_dat_abort_end(dat, oldreq);
245         nilfs_dat_abort_alloc(dat, newreq);
246 }
247
248 /**
249  * nilfs_dat_mark_dirty -
250  * @dat: DAT file inode
251  * @vblocknr: virtual block number
252  *
253  * Description:
254  *
255  * Return Value: On success, 0 is returned. On error, one of the following
256  * negative error codes is returned.
257  *
258  * %-EIO - I/O error.
259  *
260  * %-ENOMEM - Insufficient amount of memory available.
261  */
262 int nilfs_dat_mark_dirty(struct inode *dat, __u64 vblocknr)
263 {
264         struct nilfs_palloc_req req;
265         int ret;
266
267         req.pr_entry_nr = vblocknr;
268         ret = nilfs_dat_prepare_entry(dat, &req, 0);
269         if (ret == 0)
270                 nilfs_dat_commit_entry(dat, &req);
271         return ret;
272 }
273
274 /**
275  * nilfs_dat_freev - free virtual block numbers
276  * @dat: DAT file inode
277  * @vblocknrs: array of virtual block numbers
278  * @nitems: number of virtual block numbers
279  *
280  * Description: nilfs_dat_freev() frees the virtual block numbers specified by
281  * @vblocknrs and @nitems.
282  *
283  * Return Value: On success, 0 is returned. On error, one of the following
284  * negative error codes is returned.
285  *
286  * %-EIO - I/O error.
287  *
288  * %-ENOMEM - Insufficient amount of memory available.
289  *
290  * %-ENOENT - The virtual block number have not been allocated.
291  */
292 int nilfs_dat_freev(struct inode *dat, __u64 *vblocknrs, size_t nitems)
293 {
294         return nilfs_palloc_freev(dat, vblocknrs, nitems);
295 }
296
297 /**
298  * nilfs_dat_move - change a block number
299  * @dat: DAT file inode
300  * @vblocknr: virtual block number
301  * @blocknr: block number
302  *
303  * Description: nilfs_dat_move() changes the block number associated with
304  * @vblocknr to @blocknr.
305  *
306  * Return Value: On success, 0 is returned. On error, one of the following
307  * negative error codes is returned.
308  *
309  * %-EIO - I/O error.
310  *
311  * %-ENOMEM - Insufficient amount of memory available.
312  */
313 int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr)
314 {
315         struct buffer_head *entry_bh;
316         struct nilfs_dat_entry *entry;
317         void *kaddr;
318         int ret;
319
320         ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
321         if (ret < 0)
322                 return ret;
323
324         /*
325          * The given disk block number (blocknr) is not yet written to
326          * the device at this point.
327          *
328          * To prevent nilfs_dat_translate() from returning the
329          * uncommitted block number, this makes a copy of the entry
330          * buffer and redirects nilfs_dat_translate() to the copy.
331          */
332         if (!buffer_nilfs_redirected(entry_bh)) {
333                 ret = nilfs_mdt_freeze_buffer(dat, entry_bh);
334                 if (ret) {
335                         brelse(entry_bh);
336                         return ret;
337                 }
338         }
339
340         kaddr = kmap_atomic(entry_bh->b_page);
341         entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
342         if (unlikely(entry->de_blocknr == cpu_to_le64(0))) {
343                 nilfs_msg(dat->i_sb, KERN_CRIT,
344                           "%s: invalid vblocknr = %llu, [%llu, %llu)",
345                           __func__, (unsigned long long)vblocknr,
346                           (unsigned long long)le64_to_cpu(entry->de_start),
347                           (unsigned long long)le64_to_cpu(entry->de_end));
348                 kunmap_atomic(kaddr);
349                 brelse(entry_bh);
350                 return -EINVAL;
351         }
352         WARN_ON(blocknr == 0);
353         entry->de_blocknr = cpu_to_le64(blocknr);
354         kunmap_atomic(kaddr);
355
356         mark_buffer_dirty(entry_bh);
357         nilfs_mdt_mark_dirty(dat);
358
359         brelse(entry_bh);
360
361         return 0;
362 }
363
364 /**
365  * nilfs_dat_translate - translate a virtual block number to a block number
366  * @dat: DAT file inode
367  * @vblocknr: virtual block number
368  * @blocknrp: pointer to a block number
369  *
370  * Description: nilfs_dat_translate() maps the virtual block number @vblocknr
371  * to the corresponding block number.
372  *
373  * Return Value: On success, 0 is returned and the block number associated
374  * with @vblocknr is stored in the place pointed by @blocknrp. On error, one
375  * of the following negative error codes is returned.
376  *
377  * %-EIO - I/O error.
378  *
379  * %-ENOMEM - Insufficient amount of memory available.
380  *
381  * %-ENOENT - A block number associated with @vblocknr does not exist.
382  */
383 int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp)
384 {
385         struct buffer_head *entry_bh, *bh;
386         struct nilfs_dat_entry *entry;
387         sector_t blocknr;
388         void *kaddr;
389         int ret;
390
391         ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
392         if (ret < 0)
393                 return ret;
394
395         if (!nilfs_doing_gc() && buffer_nilfs_redirected(entry_bh)) {
396                 bh = nilfs_mdt_get_frozen_buffer(dat, entry_bh);
397                 if (bh) {
398                         WARN_ON(!buffer_uptodate(bh));
399                         brelse(entry_bh);
400                         entry_bh = bh;
401                 }
402         }
403
404         kaddr = kmap_atomic(entry_bh->b_page);
405         entry = nilfs_palloc_block_get_entry(dat, vblocknr, entry_bh, kaddr);
406         blocknr = le64_to_cpu(entry->de_blocknr);
407         if (blocknr == 0) {
408                 ret = -ENOENT;
409                 goto out;
410         }
411         *blocknrp = blocknr;
412
413  out:
414         kunmap_atomic(kaddr);
415         brelse(entry_bh);
416         return ret;
417 }
418
419 ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned int visz,
420                             size_t nvi)
421 {
422         struct buffer_head *entry_bh;
423         struct nilfs_dat_entry *entry;
424         struct nilfs_vinfo *vinfo = buf;
425         __u64 first, last;
426         void *kaddr;
427         unsigned long entries_per_block = NILFS_MDT(dat)->mi_entries_per_block;
428         int i, j, n, ret;
429
430         for (i = 0; i < nvi; i += n) {
431                 ret = nilfs_palloc_get_entry_block(dat, vinfo->vi_vblocknr,
432                                                    0, &entry_bh);
433                 if (ret < 0)
434                         return ret;
435                 kaddr = kmap_atomic(entry_bh->b_page);
436                 /* last virtual block number in this block */
437                 first = vinfo->vi_vblocknr;
438                 do_div(first, entries_per_block);
439                 first *= entries_per_block;
440                 last = first + entries_per_block - 1;
441                 for (j = i, n = 0;
442                      j < nvi && vinfo->vi_vblocknr >= first &&
443                              vinfo->vi_vblocknr <= last;
444                      j++, n++, vinfo = (void *)vinfo + visz) {
445                         entry = nilfs_palloc_block_get_entry(
446                                 dat, vinfo->vi_vblocknr, entry_bh, kaddr);
447                         vinfo->vi_start = le64_to_cpu(entry->de_start);
448                         vinfo->vi_end = le64_to_cpu(entry->de_end);
449                         vinfo->vi_blocknr = le64_to_cpu(entry->de_blocknr);
450                 }
451                 kunmap_atomic(kaddr);
452                 brelse(entry_bh);
453         }
454
455         return nvi;
456 }
457
458 /**
459  * nilfs_dat_read - read or get dat inode
460  * @sb: super block instance
461  * @entry_size: size of a dat entry
462  * @raw_inode: on-disk dat inode
463  * @inodep: buffer to store the inode
464  */
465 int nilfs_dat_read(struct super_block *sb, size_t entry_size,
466                    struct nilfs_inode *raw_inode, struct inode **inodep)
467 {
468         static struct lock_class_key dat_lock_key;
469         struct inode *dat;
470         struct nilfs_dat_info *di;
471         int err;
472
473         if (entry_size > sb->s_blocksize) {
474                 nilfs_msg(sb, KERN_ERR, "too large DAT entry size: %zu bytes",
475                           entry_size);
476                 return -EINVAL;
477         } else if (entry_size < NILFS_MIN_DAT_ENTRY_SIZE) {
478                 nilfs_msg(sb, KERN_ERR, "too small DAT entry size: %zu bytes",
479                           entry_size);
480                 return -EINVAL;
481         }
482
483         dat = nilfs_iget_locked(sb, NULL, NILFS_DAT_INO);
484         if (unlikely(!dat))
485                 return -ENOMEM;
486         if (!(dat->i_state & I_NEW))
487                 goto out;
488
489         err = nilfs_mdt_init(dat, NILFS_MDT_GFP, sizeof(*di));
490         if (err)
491                 goto failed;
492
493         err = nilfs_palloc_init_blockgroup(dat, entry_size);
494         if (err)
495                 goto failed;
496
497         di = NILFS_DAT_I(dat);
498         lockdep_set_class(&di->mi.mi_sem, &dat_lock_key);
499         nilfs_palloc_setup_cache(dat, &di->palloc_cache);
500         nilfs_mdt_setup_shadow_map(dat, &di->shadow);
501
502         err = nilfs_read_inode_common(dat, raw_inode);
503         if (err)
504                 goto failed;
505
506         unlock_new_inode(dat);
507  out:
508         *inodep = dat;
509         return 0;
510  failed:
511         iget_failed(dat);
512         return err;
513 }