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