gtfs: Support intra-directory rename
[akaros.git] / kern / drivers / dev / gtfs.c
1 /* Copyright (c) 2018 Google Inc
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * #gtfs, generic tree file system frontend that hooks to a backend 9p device
6  */
7
8 #include <slab.h>
9 #include <kmalloc.h>
10 #include <kref.h>
11 #include <string.h>
12 #include <stdio.h>
13 #include <assert.h>
14 #include <error.h>
15 #include <pmap.h>
16 #include <smp.h>
17 #include <tree_file.h>
18
19 struct dev gtfs_devtab;
20
21 static char *devname(void)
22 {
23         return gtfs_devtab.name;
24 }
25
26 struct gtfs {
27         struct tree_filesystem          tfs;
28         struct kref                                     users;
29 };
30
31 /* Blob hanging off the fs_file->priv.  The backend chans are only accessed,
32  * (changed or used) with the corresponding fs_file qlock held.  That's the
33  * primary use of the qlock - we might be able to avoid qlocking with increfs
34  * and atomics or spinlocks, but be careful of be_length.  Qlocking doesn't
35  * matter much yet since #mnt serializes.
36  *
37  * The walk chan is never opened - it's basically just the walked fid, from
38  * which we can do other walks or get the I/O chans.  The read and write chans
39  * are opened on demand and closed periodically.  We open them initially on
40  * open/create in case we are unable to open them (e.g. unwritable).  Better to
41  * find out early than during a long writeback.
42  *
43  * The mnt server might complain about having too many open fids.  We can run a
44  * ktask that periodically closes the be_chans on any LRU'd files.
45  *
46  * be_{length,mode,mtime} should be what the remote server thinks they are -
47  * especially for length and mode.  The invariant is that e.g. the file's length
48  * == be_length, and the qlock protects that invariant.  We don't care as much
49  * about mtime, since some 9p servers just change that on their own. */
50 struct gtfs_priv {
51         struct chan                                     *be_walk;       /* never opened */
52         struct chan                                     *be_read;
53         struct chan                                     *be_write;
54         uint64_t                                        be_length;
55         uint32_t                                        be_mode;
56         struct timespec                         be_mtime;
57         bool                                            was_removed;
58 };
59
60 static inline struct gtfs_priv *fsf_to_gtfs_priv(struct fs_file *f)
61 {
62         return f->priv;
63 }
64
65 static inline struct gtfs_priv *tf_to_gtfs_priv(struct tree_file *tf)
66 {
67         return fsf_to_gtfs_priv(&tf->file);
68 }
69
70 /* Helper.  Clones the chan (walks to itself) and then opens with omode. */
71 static struct chan *cclone_and_open(struct chan *c, int omode)
72 {
73         ERRSTACK(1);
74         struct chan *new;
75
76         new = cclone(c);
77         if (waserror()) {
78                 cclose(new);
79                 nexterror();
80         }
81         new = devtab[new->type].open(new, omode);
82         poperror();
83         return new;
84 }
85
86 /* Send a wstat with the contents of dir for the file. */
87 static void wstat_dir(struct fs_file *f, struct dir *dir)
88 {
89         ERRSTACK(1);
90         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
91         size_t sz;
92         uint8_t *buf;
93
94         sz = sizeD2M(dir);
95         buf = kzmalloc(sz, MEM_WAIT);
96         convD2M(dir, buf, sz);
97         if (waserror()) {
98                 kfree(buf);
99                 nexterror();
100         }
101         devtab[gp->be_walk->type].wstat(gp->be_walk, buf, sz);
102         kfree(buf);
103         poperror();
104 }
105
106 /* Note we only track and thus change the following:
107  * - length
108  * - mode
109  * - mtime (second granularity)
110  * If we support chown, we'll have to do something else there.  See
111  * fs_file_copy_from_dir(). */
112 static void sync_metadata(struct fs_file *f)
113 {
114         ERRSTACK(1);
115         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
116         struct dir dir;
117         bool send_it = false;
118
119         qlock(&f->qlock);
120         init_empty_dir(&dir);
121         if (f->dir.length != gp->be_length) {
122                 dir.length = f->dir.length;
123                 send_it = true;
124         }
125         if (f->dir.mode != gp->be_mode) {
126                 dir.mode = f->dir.mode;
127                 send_it = true;
128         }
129         if (f->dir.mtime.tv_sec != gp->be_mtime.tv_sec) {
130                 /* ninep's UFS server assumes you set both atime and mtime */
131                 dir.atime.tv_sec = f->dir.atime.tv_sec;
132                 dir.atime.tv_nsec = f->dir.atime.tv_nsec;
133                 dir.mtime.tv_sec = f->dir.mtime.tv_sec;
134                 dir.mtime.tv_nsec = f->dir.mtime.tv_nsec;
135                 send_it = true;
136         }
137         if (!send_it) {
138                 qunlock(&f->qlock);
139                 return;
140         }
141         if (waserror()) {
142                 qunlock(&f->qlock);
143                 nexterror();
144         }
145         wstat_dir(f, &dir);
146         /* We set these after the wstat succeeds.  If we set them earlier, we'd have
147          * to roll back.  Remember the invariant: the be_values match the backend's
148          * file's values.  We should be able to stat be_walk and check these (though
149          * the 9p server might muck with atime/mtime). */
150         if (f->dir.length != gp->be_length)
151                 gp->be_length = f->dir.length;
152         if (f->dir.mode != gp->be_mode)
153                 gp->be_mode = f->dir.mode;
154         if (f->dir.mtime.tv_sec != gp->be_mtime.tv_sec)
155                 gp->be_mtime = f->dir.mtime;
156         qunlock(&f->qlock);
157         poperror();
158 }
159
160 /* Can throw on error, currently from sync_metadata. */
161 static void writeback_file(struct fs_file *f)
162 {
163         sync_metadata(f);
164         /* This is a lockless peak.  Once a file is dirtied, we never undirty it.
165          * To do so, we need the file qlock (not a big deal, though that may replace
166          * the PM qlock), and we still need to handle/scan mmaps.  Specifically, we
167          * only dirty when an mmap attaches (PROT_WRITE and MAP_SHARED), but we
168          * don't know if an existing mapping has caused more dirtying (an mmap can
169          * re-dirty then detach before our next writeback).  That usually requires a
170          * scan.  This is all an optimization to avoid scanning the entire PM's
171          * pages for whether or not they are dirty.
172          *
173          * Also, our writeback pm op grabs the file's qlock.  So be careful; though
174          * we could use another qlock, since we're mostly protecting backend state.
175          */
176         if (qid_is_file(f->dir.qid) && (f->flags & FSF_DIRTY))
177                 pm_writeback_pages(f->pm);
178 }
179
180 static void purge_cb(struct tree_file *tf)
181 {
182         ERRSTACK(1)
183
184         /* discard error, and keep on going if we can. */
185         if (!waserror())
186                 writeback_file(&tf->file);
187         poperror();
188 }
189
190 static void __gtfs_destroy(uint32_t srcid, long a0, long a1, long a2)
191 {
192         struct gtfs *gtfs = (struct gtfs*)a0;
193
194         tfs_frontend_purge(&gtfs->tfs, purge_cb);
195         /* this is the ref from attach */
196         assert(kref_refcnt(&gtfs->tfs.root->kref) == 1);
197         tf_kref_put(gtfs->tfs.root);
198         /* ensures __tf_free() happens before tfs_destroy */
199         rcu_barrier();
200         tfs_destroy(&gtfs->tfs);
201         kfree(gtfs);
202 }
203
204 static void gtfs_release(struct kref *kref)
205 {
206         struct gtfs *gtfs = container_of(kref, struct gtfs, users);
207
208         /* We can't use RCU within an RCU callback, and release methods are often
209          * called from within callbacks.  We can use a kernel message, which can
210          * block and do whatever else it wants.  In essence, we break the connection
211          * to our current context (the rcu_mgmt_ktask) by using a kmsg. */
212         send_kernel_message(core_id(), __gtfs_destroy, (long)gtfs, 0, 0,
213                             KMSG_ROUTINE);
214 }
215
216 static struct gtfs *chan_to_gtfs(struct chan *c)
217 {
218         struct tree_file *tf = chan_to_tree_file(c);
219
220         return (struct gtfs*)(tf->tfs);
221 }
222
223 static void incref_gtfs_chan(struct chan *c)
224 {
225         kref_get(&chan_to_gtfs(c)->users, 1);
226 }
227
228 static void decref_gtfs_chan(struct chan *c)
229 {
230         kref_put(&chan_to_gtfs(c)->users);
231 }
232
233 static struct walkqid *gtfs_walk(struct chan *c, struct chan *nc, char **name,
234                                  unsigned int nname)
235 {
236         struct walkqid *wq;
237
238         wq = tree_chan_walk(c, nc, name, nname);
239         if (wq && wq->clone && (wq->clone != c))
240                 incref_gtfs_chan(wq->clone);
241         return wq;
242 }
243
244 /* Given an omode, make sure the be chans are set up */
245 static void setup_be_chans(struct chan *c, int omode)
246 {
247         ERRSTACK(1);
248         struct tree_file *tf = chan_to_tree_file(c);
249         struct fs_file *f = &tf->file;
250         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
251
252         qlock(&f->qlock);
253         if (waserror()) {
254                 qunlock(&f->qlock);
255                 nexterror();
256         }
257         /* Readers and writers both need be_read.  With fs files you can't have a
258          * writable-only file, since we need to load the page into the page cache,
259          * which is a readpage. */
260         if (!gp->be_read)
261                 gp->be_read = cclone_and_open(gp->be_walk, O_READ);
262         if (!gp->be_write && (omode & O_WRITE))
263                 gp->be_write = cclone_and_open(gp->be_walk, O_WRITE);
264         qunlock(&f->qlock);
265         poperror();
266 }
267
268 static struct chan *gtfs_open(struct chan *c, int omode)
269 {
270         /* truncate can happen before we setup the be_chans.  if we need those, we
271          * can swap the order */
272         c = tree_chan_open(c, omode);
273         setup_be_chans(c, omode);
274         return c;
275 }
276
277
278 static void gtfs_create(struct chan *c, char *name, int omode, uint32_t perm,
279                         char *ext)
280 {
281         tree_chan_create(c, name, omode, perm, ext);
282         /* We have to setup *after* create, since it moves the chan from the parent
283          * to the new file. */
284         setup_be_chans(c, omode);
285 }
286
287 static void gtfs_close(struct chan *c)
288 {
289         tree_chan_close(c);
290         decref_gtfs_chan(c);
291 }
292
293 static void gtfs_remove(struct chan *c)
294 {
295         ERRSTACK(1);
296         struct gtfs *gtfs = chan_to_gtfs(c);
297
298         if (waserror()) {
299                 /* Same old pain-in-the-ass for remove */
300                 kref_put(&gtfs->users);
301                 nexterror();
302         }
303         tree_chan_remove(c);
304         kref_put(&gtfs->users);
305         poperror();
306 }
307
308 static size_t gtfs_wstat(struct chan *c, uint8_t *m_buf, size_t m_buf_sz)
309 {
310         size_t ret;
311
312         ret = tree_chan_wstat(c, m_buf, m_buf_sz);
313         /* Tell the backend so that any metadata changes take effect immediately.
314          * Consider chmod +w.  We need to tell the 9p server so that it will allow
315          * future accesses. */
316         sync_metadata(&chan_to_tree_file(c)->file);
317         return ret;
318 }
319
320 /* Caller holds the file's qlock. */
321 static size_t __gtfs_fsf_read(struct fs_file *f, void *ubuf, size_t n,
322                               off64_t off)
323 {
324         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
325
326         if (off >= gp->be_length) {
327                 /* We can skip the RPC, since we know it will return zero (EOF). */
328                 return 0;
329         }
330         if (!gp->be_read)
331                 gp->be_read = cclone_and_open(gp->be_walk, O_READ);
332         return devtab[gp->be_read->type].read(gp->be_read, ubuf, n, off);
333 }
334
335 /* Reads a file from its backend chan */
336 static size_t gtfs_fsf_read(struct fs_file *f, void *ubuf, size_t n,
337                             off64_t off)
338 {
339         ERRSTACK(1);
340         size_t ret;
341
342         qlock(&f->qlock);
343         if (waserror()) {
344                 qunlock(&f->qlock);
345                 nexterror();
346         }
347         ret = __gtfs_fsf_read(f, ubuf, n, off);
348         qunlock(&f->qlock);
349         poperror();
350         return ret;
351 }
352
353 /* Caller holds the file's qlock. */
354 static size_t __gtfs_fsf_write(struct fs_file *f, void *ubuf, size_t n,
355                                off64_t off)
356 {
357         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
358         size_t ret;
359
360         if (!gp->be_write)
361                 gp->be_write = cclone_and_open(gp->be_walk, O_WRITE);
362         ret = devtab[gp->be_write->type].write(gp->be_write, ubuf, n, off);
363         gp->be_length = MAX(gp->be_length, n + ret);
364         return ret;
365 }
366
367 /* Writes a file to its backend chan */
368 static size_t gtfs_fsf_write(struct fs_file *f, void *ubuf, size_t n,
369                              off64_t off)
370 {
371         ERRSTACK(1);
372         size_t ret;
373
374         qlock(&f->qlock);
375         if (waserror()) {
376                 qunlock(&f->qlock);
377                 nexterror();
378         }
379         ret = __gtfs_fsf_write(f, ubuf, n, off);
380         qunlock(&f->qlock);
381         poperror();
382         return ret;
383 }
384
385 static size_t gtfs_read(struct chan *c, void *ubuf, size_t n, off64_t off)
386 {
387         struct tree_file *tf = chan_to_tree_file(c);
388
389         if (tree_file_is_dir(tf))
390                 return gtfs_fsf_read(&tf->file, ubuf, n, off);
391         return fs_file_read(&tf->file, ubuf, n, off);
392 }
393
394 /* Given a file (with dir->name set), couple it and sync to the backend chan.
395  * This will store/consume the ref for backend, in the TF (freed with
396  * gtfs_tf_free), even on error, unless you zero out the be_walk field. */
397 static void gtfs_tf_couple_backend(struct tree_file *tf, struct chan *backend)
398 {
399         struct dir *dir;
400         struct gtfs_priv *gp = kzmalloc(sizeof(struct gtfs_priv), MEM_WAIT);
401
402         tf->file.priv = gp;
403         tf->file.dir.qid = backend->qid;
404         gp->be_walk = backend;
405         dir = chandirstat(backend);
406         if (!dir)
407                 error(ENOMEM, "chandirstat failed");
408         fs_file_copy_from_dir(&tf->file, dir);
409         kfree(dir);
410         /* For sync_metadata */
411         gp->be_length = tf->file.dir.length;
412         gp->be_mode = tf->file.dir.mode;
413         gp->be_mtime = tf->file.dir.mtime;
414 }
415
416 static void gtfs_tf_free(struct tree_file *tf)
417 {
418         struct gtfs_priv *gp = tf_to_gtfs_priv(tf);
419
420         /* Might have some partially / never constructed tree files */
421         if (!gp)
422                 return;
423         if (gp->was_removed) {
424                 gp->be_walk->type = -1;
425                 /* sanity */
426                 assert(kref_refcnt(&gp->be_walk->ref) == 1);
427         }
428         cclose(gp->be_walk);
429         /* I/O chans can be NULL */
430         cclose(gp->be_read);
431         cclose(gp->be_write);
432         kfree(gp);
433 }
434
435 static void gtfs_tf_unlink(struct tree_file *parent, struct tree_file *child)
436 {
437         struct gtfs_priv *gp = tf_to_gtfs_priv(child);
438         struct chan *be_walk = gp->be_walk;
439
440         /* Remove clunks the be_walk chan/fid.  if it succeeded (and I think even if
441          * it didn't), we shouldn't close that fid again, which is what will happen
442          * soon after this function.  The TF code calls unlink, then when the last
443          * ref closes the TF, it'll get freed and we'll call back to gtfs_tf_free().
444          *
445          * This is the same issue we run into with all of the device remove ops
446          * where we want to refcnt something hanging off e.g. c->aux.  In 9p, you're
447          * not supposed to close a chan/fid that was already removed.
448          *
449          * Now here's the weird thing.  We can close the be_walk chan after remove,
450          * but it's possible that someone has walked and perhaps opened a frontend
451          * chan + TF, but hasn't done a read yet.  So someone might want to set up
452          * be_read, but they can't due to be_walk being closed.  We could give them
453          * a 'phase error' (one of 9p's errors for I/O on a removed file).
454          *
455          * Alternatively, we can mark the gtfs_priv so that when we do free it, we
456          * skip the dev.remove, similar to what sysremove() does.  That's probably
457          * easier.  This is technically racy, but we know that the release/free
458          * method won't be called until we return. */
459         gp->was_removed = true;
460         devtab[be_walk->type].remove(be_walk);
461 }
462
463 /* Caller sets the name, but doesn't know if it exists or not.  It's our job to
464  * find out if it exists and fill in the child structure appropriately.  For
465  * negative entries, just flagging it is fine.  Otherwise, we fill in the dir.
466  * We should throw on error. */
467 static void gtfs_tf_lookup(struct tree_file *parent, struct tree_file *child)
468 {
469         struct walkqid *wq;
470         struct chan *be_walk = tf_to_gtfs_priv(parent)->be_walk;
471         struct chan *child_be_walk;
472
473         wq = devtab[be_walk->type].walk(be_walk, NULL, &child->file.dir.name, 1);
474         if (!wq || !wq->clone) {
475                 kfree(wq);
476                 /* This isn't racy, since the child isn't linked to the tree yet */
477                 child->flags |= TF_F_NEGATIVE | TF_F_HAS_BEEN_USED;
478                 return;
479         }
480         /* walk shouldn't give us the same chan struct since we gave it a name and a
481          * NULL nc. */
482         assert(wq->clone != be_walk);
483         /* only gave it one name, and it didn't fail. */
484         assert(wq->nqid == 1);
485         /* sanity */
486         assert(wq->clone->qid.path == wq->qid[wq->nqid - 1].path);
487         child_be_walk = wq->clone;
488         kfree(wq);
489         gtfs_tf_couple_backend(child, child_be_walk);
490 }
491
492 static void gtfs_tf_create(struct tree_file *parent, struct tree_file *child,
493                            int perm)
494 {
495         ERRSTACK(1);
496         struct chan *c = cclone(tf_to_gtfs_priv(parent)->be_walk);
497
498         if (waserror()) {
499                 cclose(c);
500                 nexterror();
501         }
502         devtab[c->type].create(c, tree_file_to_name(child), 0, perm,
503                                child->file.dir.ext);
504         /* The chan c is opened, which we don't want.  We can't cclone it either
505          * (since it is opened).  All we can do is have the parent walk again so we
506          * can get the child's unopened be_walk chan.  Conveniently, that's
507          * basically a lookup, so create is really two things: make it, then look it
508          * up from the backend. */
509         cclose(c);
510         poperror();
511         if (waserror()) {
512                 warn("File %s was created in the backend, but unable to look it up!",
513                      tree_file_to_name(child));
514                 nexterror();
515         }
516         gtfs_tf_lookup(parent, child);
517         poperror();
518 }
519
520 static void gtfs_wstat_rename(struct fs_file *f, const char *name)
521 {
522         struct dir dir;
523
524         init_empty_dir(&dir);
525         dir.name = (char*)name;
526         wstat_dir(f, &dir);
527 }
528
529 static void gtfs_tf_rename(struct tree_file *tf, struct tree_file *old_parent,
530                            struct tree_file *new_parent, const char *name,
531                            int flags)
532 {
533         struct chan *tf_c = tf_to_gtfs_priv(tf)->be_walk;
534         struct chan *np_c = tf_to_gtfs_priv(new_parent)->be_walk;
535
536         if (!devtab[tf_c->type].rename) {
537                 /* 9p can handle intra-directory renames, though some Akaros #devices
538                  * might throw. */
539                 if (old_parent == new_parent) {
540                         gtfs_wstat_rename(&tf->file, name);
541                         return;
542                 }
543                 error(EXDEV, "%s: %s doesn't support rename", devname(),
544                       devtab[tf_c->type].name);
545         }
546         devtab[tf_c->type].rename(tf_c, np_c, name, flags);
547 }
548
549 static bool gtfs_tf_has_children(struct tree_file *parent)
550 {
551         struct dir dir[1];
552
553         assert(tree_file_is_dir(parent));       /* TF bug */
554         /* Any read should work, but there might be issues asking for something
555          * smaller than a dir.
556          *
557          * Note we use the unlocked read here.  The fs_file's qlock is held by our
558          * caller, and we reuse that qlock for the sync for reading/writing. */
559         return __gtfs_fsf_read(&parent->file, dir, sizeof(struct dir), 0) > 0;
560 }
561
562 struct tree_file_ops gtfs_tf_ops = {
563         .free = gtfs_tf_free,
564         .unlink = gtfs_tf_unlink,
565         .lookup = gtfs_tf_lookup,
566         .create = gtfs_tf_create,
567         .rename = gtfs_tf_rename,
568         .has_children = gtfs_tf_has_children,
569 };
570
571 /* Fills page with its contents from its backing store file.
572  *
573  * Note the page/offset might be beyond the current file length, based on the
574  * current pagemap code. */
575 static int gtfs_pm_readpage(struct page_map *pm, struct page *pg)
576 {
577         ERRSTACK(1);
578         void *kva = page2kva(pg);
579         off64_t offset = pg->pg_index << PGSHIFT;
580         size_t ret;
581
582         if (waserror()) {
583                 poperror();
584                 return -get_errno();
585         }
586         /* If offset is beyond the length of the file, the 9p device/server should
587          * return 0.  We'll just init an empty page.  The length on the frontend (in
588          * the fsf->dir.length) will be adjusted.  The backend will hear about it on
589          * the next sync. */
590         ret = gtfs_fsf_read(pm->pm_file, kva, PGSIZE, offset);
591         poperror();
592         if (ret < PGSIZE)
593                 memset(kva + ret, 0, PGSIZE - ret);
594         atomic_or(&pg->pg_flags, PG_UPTODATE);
595         return 0;
596 }
597
598 /* Meant to take the page from PM and flush to backing store. */
599 static int gtfs_pm_writepage(struct page_map *pm, struct page *pg)
600 {
601         ERRSTACK(1);
602         struct fs_file *f = pm->pm_file;
603         void *kva = page2kva(pg);
604         off64_t offset = pg->pg_index << PGSHIFT;
605         size_t amt;
606
607         qlock(&f->qlock);
608         if (waserror()) {
609                 qunlock(&f->qlock);
610                 poperror();
611                 return -get_errno();
612         }
613         /* Don't writeback beyond the length of the file.  Most of the time this
614          * comes up is when the len is in the middle of the last page. */
615         if (offset >= fs_file_get_length(f)) {
616                 qunlock(&f->qlock);
617                 return 0;
618         }
619         amt = MIN(PGSIZE, fs_file_get_length(f) - offset);
620         __gtfs_fsf_write(f, kva, amt, offset);
621         qunlock(&f->qlock);
622         poperror();
623         return 0;
624 }
625
626 /* Caller holds the file's qlock */
627 static void __trunc_to(struct fs_file *f, off64_t begin)
628 {
629         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
630         struct dir dir;
631
632         init_empty_dir(&dir);
633         dir.length = begin;
634         wstat_dir(f, &dir);
635         /* recall the invariant: be_length == the backend's length */
636         gp->be_length = begin;
637 }
638
639 /* Caller holds the file's qlock */
640 static void __zero_fill(struct fs_file *f, off64_t begin, off64_t end)
641 {
642         ERRSTACK(1);
643         void *zeros;
644
645         if (PGOFF(begin) || PGOFF(end))
646                 error(EINVAL, "zero_fill had unaligned begin (%p) or end (%p)\n",
647                       begin, end);
648         zeros = kpages_zalloc(PGSIZE, MEM_WAIT);
649         if (waserror()) {
650                 kpages_free(zeros, PGSIZE);
651                 nexterror();
652         }
653         for (off64_t o = begin; o < end; o += PGSIZE)
654                 __gtfs_fsf_write(f, zeros, PGSIZE, o);
655         poperror();
656 }
657
658 /* The intent here is for the backend to drop all data in the range.  Zeros are
659  * OK - any future read should get a zero.
660  *
661  * These offsets are the beginning and end of the hole to punch.  The TF code
662  * already dealt with edge cases, so these happen to be page aligned.  That
663  * shouldn't matter for the backend device.
664  *
665  * Don't worry about a border page for end that is all zeros.
666  * fs_file_truncate() rounded up to the nearest page to avoid issues.  The user
667  * could manually punch a hole, and they could create a page of zeros at end.
668  * We don't care.
669  *
670  * 9p doesn't have a hole-punch, so we'll truncate if we can and o/w fill with
671  * zeros.
672  *
673  * Note that the frontend's file length often differs from the backend.  Under
674  * normal operation, such as writing to a file, the frontend's len will be
675  * greater than the backend's.  When we sync, the backend learns the real
676  * length.  Similarly, when we shrink a gile, the backend's length may be
677  * greater than the frontend.  Consider a truncate from 8192 to 4095: we punch
678  * with begin = 4096, end = 8192.  In either case, the backend learns the real
679  * length on a sync.  In punch_hole, we're just trying to discard old data. */
680 static void gtfs_fs_punch_hole(struct fs_file *f, off64_t begin, off64_t end)
681 {
682         ERRSTACK(1);
683         struct gtfs_priv *gp = fsf_to_gtfs_priv(f);
684
685         qlock(&f->qlock);
686         if (waserror()) {
687                 qunlock(&f->qlock);
688                 nexterror();
689         }
690         if (end >= gp->be_length) {
691                 if (begin < gp->be_length)
692                         __trunc_to(f, begin);
693         } else {
694                 __zero_fill(f, begin, end);
695         }
696         qunlock(&f->qlock);
697         poperror();
698 }
699
700 static bool gtfs_fs_can_grow_to(struct fs_file *f, size_t len)
701 {
702         /* TODO: are there any limits in 9p? */
703         return true;
704 }
705
706 struct fs_file_ops gtfs_fs_ops = {
707         .readpage = gtfs_pm_readpage,
708         .writepage = gtfs_pm_writepage,
709         .punch_hole = gtfs_fs_punch_hole,
710         .can_grow_to = gtfs_fs_can_grow_to,
711 };
712
713 /* We're passed a backend chan, usually of type #mnt, used for an uncached
714  * mount.  We call it 'backend.'  It is the result of an attach, e.g. mntattach.
715  * In the case of #mnt, this chan is different than the one that has the 9p
716  * server on the other side, called 'mchan'.  That chan is at backend->mchan,
717  * and also the struct mnt->c.  The struct mnt is shared by all mounts talking
718  * to the 9p server over the mchan, and is stored at mchan->mux.  Backend chans
719  * have a strong (counted) ref on the mchan.
720  *
721  * We create and return a chan of #gtfs, suitable for attaching to the
722  * namespace.  This chan will have the root TF hanging off aux, just like how
723  * any other attached TFS has a root TF.  #gtfs manages the linkage between a TF
724  * and the backend, which is the purpose of gtfs_priv.
725  *
726  * A note on refcounts: in the normal, uncached operation, the 'backend' chan
727  * has a ref (actually a chan kref, which you cclose) on the comms chan (mchan).
728  * We get one ref at mntattach time, and every distinct mntwalk gets another
729  * ref.  Those actually get closed in chanfree(), since they are stored at
730  * mchan.
731  *
732  * All gtfs *tree_files* have at least one refcounted chan corresponding to the
733  * file/FID on the backend server.  Think of it as a 1:1 connection, even though
734  * there is more than one chan.  The gtfs device can have many chans pointing to
735  * the same TF, which is kreffed.  That TF is 1:1 on a backend object.
736  *
737  * All walks from this attach point will get chans with TFs from this TFS and
738  * will incref the struct gtfs.
739  */
740 static struct chan *gtfs_attach(char *arg)
741 {
742         ERRSTACK(2);
743         struct chan *backend = (struct chan*)arg;
744         struct chan *frontend;
745         struct tree_filesystem *tfs;
746         struct gtfs *gtfs;
747
748         frontend = devattach(devname(), 0);
749         if (waserror()) {
750                 /* same as #mnt - don't cclose, since we don't want to devtab close, and
751                  * we know the ref == 1 here. */
752                 chanfree(frontend);
753                 nexterror();
754         }
755         gtfs = kzmalloc(sizeof(struct gtfs), MEM_WAIT);
756         /* This 'users' kref is the one that every distinct frontend chan has.
757          * These come from attaches and successful, 'moving' walks. */
758         kref_init(&gtfs->users, gtfs_release, 1);
759         tfs = (struct tree_filesystem*)gtfs;
760         /* This gives us one ref on root, released during gtfs_release().  name is
761          * set to ".", though that gets overwritten during coupling. */
762         tfs_init(tfs);
763         if (waserror()) {
764                 /* don't consume the backend ref on error, caller expects to have it */
765                 tf_to_gtfs_priv(tfs->root)->be_walk = NULL;
766                 /* ref from tfs_init.  this should free the TF. */
767                 tf_kref_put(tfs->root);
768                 tfs_destroy(tfs);
769                 kfree(gtfs);
770                 nexterror();
771         }
772         /* stores the ref for 'backend' inside tfs->root */
773         gtfs_tf_couple_backend(tfs->root, backend);
774         poperror();
775         tfs->tf_ops = gtfs_tf_ops;
776         tfs->fs_ops = gtfs_fs_ops;
777         /* need another ref on root for the frontend chan */
778         tf_kref_get(tfs->root);
779         chan_set_tree_file(frontend, tfs->root);
780         poperror();
781         return frontend;
782 }
783
784 static bool lru_prune_cb(struct tree_file *tf)
785 {
786         ERRSTACK(1);
787
788         if (waserror()) {
789                 /* not much to do - ssh the file out? */
790                 printk("Failed to sync file %s: %s\n", tree_file_to_name(tf),
791                        current_errstr());
792                 poperror();
793                 return false;
794         }
795         writeback_file(&tf->file);
796         poperror();
797         return true;
798 }
799
800 static void pressure_dfs_cb(struct tree_file *tf)
801 {
802         if (!tree_file_is_dir(tf))
803                 pm_free_unused_pages(tf->file.pm);
804 }
805
806 /* Under memory pressure, there are a bunch of things we can do. */
807 static void gtfs_free_memory(struct gtfs *gtfs)
808 {
809         /* This attempts to remove every file from the LRU.  It'll write back dirty
810          * files, then if they haven't been used since we started, it'll delete the
811          * frontend TF, which will delete the entire page cache entry.  The heavy
812          * lifting is done by TF code. */
813         tfs_lru_for_each(&gtfs->tfs, lru_prune_cb, -1);
814         /* This drops the negative TFs.  It's not a huge deal, since they are small,
815          * but perhaps it'll help. */
816         tfs_lru_prune_neg(&gtfs->tfs);
817         /* This will attempt to free memory from all files in the frontend,
818          * regardless of whether or not they are in use.  This might help if you
819          * have some large files that happened to be open. */
820         tfs_frontend_for_each(&gtfs->tfs, pressure_dfs_cb);
821 }
822
823 static void gtfs_sync_tf(struct tree_file *tf)
824 {
825         writeback_file(&tf->file);
826 }
827
828 static void gtfs_sync_gtfs(struct gtfs *gtfs)
829 {
830         tfs_frontend_for_each(&gtfs->tfs, gtfs_sync_tf);
831 }
832
833 /* chan_ctl or something can hook into these functions */
834 static void gtfs_sync_chan(struct chan *c)
835 {
836         gtfs_sync_tf(chan_to_tree_file(c));
837 }
838
839 static void gtfs_sync_chans_fs(struct chan *any_c)
840 {
841         gtfs_sync_gtfs(chan_to_gtfs(any_c));
842 }
843
844 static unsigned long gtfs_chan_ctl(struct chan *c, int op, unsigned long a1,
845                                    unsigned long a2, unsigned long a3,
846                                    unsigned long a4)
847 {
848         switch (op) {
849         case CCTL_SYNC:
850                 if (tree_file_is_dir(chan_to_tree_file(c)))
851                         gtfs_sync_chans_fs(c);
852                 else
853                         gtfs_sync_chan(c);
854                 return 0;
855         default:
856                 error(EINVAL, "%s does not support %d", __func__, op);
857         }
858 }
859
860 struct dev gtfs_devtab __devtab = {
861         .name = "gtfs",
862
863         .reset = devreset,
864         .init = devinit,
865         .shutdown = devshutdown,
866         .attach = gtfs_attach,
867         .walk = gtfs_walk,
868         .stat = tree_chan_stat,
869         .open = gtfs_open,
870         .create = gtfs_create,
871         .close = gtfs_close,
872         .read = gtfs_read,
873         .bread = devbread,
874         .write = tree_chan_write,
875         .bwrite = devbwrite,
876         .remove = gtfs_remove,
877         .rename = tree_chan_rename,
878         .wstat = gtfs_wstat,
879         .power = devpower,
880         .chaninfo = devchaninfo,
881         .mmap = tree_chan_mmap,
882         .chan_ctl = gtfs_chan_ctl,
883 };