1

#include "cache.h"

     2

#include "shared/util.h"

     3

#include "shared/log.h" // only LOG_DEBUG

     4

#include "error.h"

     5

     6

#include <stdlib.h>

     7

#include <unistd.h>

     8

#include <sys/types.h>

     9

#include <sys/stat.h>

    10

#include <fcntl.h>

    11

#include <sys/mman.h>

    12

#include <errno.h>

    13

#include <assert.h>

    14

    15

    16

int pt_cache_new (struct pt_cache **cache_ptr, const char *path, int mode)

    17

{

    18

    struct pt_cache *cache;

    19

    int err;

    20

    21

    // alloc

    22

    if ((cache = calloc(1, sizeof(*cache))) == NULL)

    23

        RETURN_ERROR(PT_ERR_MEM);

    24

    25

    if ((cache->path = strdup(path)) == NULL)

    26

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    27

    28

    // init

    29

    cache->fd = -1;

    30

    cache->mode = mode;

    31

    32

    // ok

    33

    *cache_ptr = cache;

    34

    35

    return 0;

    36

    37

error:

    38

    // cleanup

    39

    if (cache)

    40

        pt_cache_destroy(cache);

    41

    42

    return err;

    43

}

    44

    45

/**

    46

 * Force-clean pt_cache, warn on errors

    47

 */

    48

static void pt_cache_abort (struct pt_cache *cache)

    49

{

    50

    if (cache->file != NULL) {

    51

        if (munmap(cache->file, sizeof(struct pt_cache_file) + cache->file->header.data_size))

    52

            log_warn_errno("munmap: %p, %zu", cache->file, sizeof(struct pt_cache_file) + cache->file->header.data_size);

    53

    54

        cache->file = NULL;

    55

    }

    56

    57

    if (cache->fd >= 0) {

    58

        if (close(cache->fd))

    59

            log_warn_errno("close: %d", cache->fd);

    60

    61

        cache->fd = -1;

    62

    }

    63

}

    64

    65

/**

    66

 * Open the cache file as an fd for reading

    67

 */

    68

static int pt_cache_open_read_fd (struct pt_cache *cache, int *fd_ptr)

    69

{

    70

    int fd;

    71

    72

    // actual open()

    73

    if ((fd = open(cache->path, O_RDONLY)) < 0)

    74

        RETURN_ERROR_ERRNO(PT_ERR_OPEN_MODE, EACCES);

    75

    76

    // ok

    77

    *fd_ptr = fd;

    78

    79

    return 0;

    80

}

    81

    82

/**

    83

 * Read in the cache header from the open file

    84

 */

    85

static int pt_cache_read_header (int fd, struct pt_cache_header *header)

    86

{

    87

    size_t len = sizeof(*header);

    88

    char *buf = (char *) header;

    89

    90

    // seek to start

    91

    if (lseek(fd, 0, SEEK_SET) != 0)

    92

        RETURN_ERROR(PT_ERR_CACHE_SEEK);

    93

    94

    // write out full header

    95

    while (len) {

    96

        ssize_t ret;

    97

    98

        // try and write out the header

    99

        if ((ret = read(fd, buf, len)) <= 0)

   100

            RETURN_ERROR(PT_ERR_CACHE_READ);

   101

   102

        // update offset

   103

        buf += ret;

   104

        len -= ret;

   105

    }

   106

   107

    // done

   108

    return 0;

   109

}

   110

   111

/**

   112

 * Read and return the version number from the cache file, temporarily opening it if needed

   113

 */

   114

static int pt_cache_version (struct pt_cache *cache)

   115

{

   116

    int fd;

   117

    struct pt_cache_header header;

   118

    int ret;

   119

   120

    // already open?

   121

    if (cache->file)

   122

        return cache->file->header.version;

   123

   124

    // temp. open

   125

    if ((ret = pt_cache_open_read_fd(cache, &fd)))

   126

        return ret;

   127

   128

    // read header

   129

    if ((ret = pt_cache_read_header(fd, &header)))

   130

        JUMP_ERROR(ret);

   131

   132

    // ok

   133

    ret = header.version;

   134

   135

error:

   136

    // close

   137

    close(fd);

   138

   139

    return ret;

   140

}

   141

   142

int pt_cache_status (struct pt_cache *cache, const char *img_path)

   143

{

   144

    struct stat st_img, st_cache;

   145

    int ver;

   146

   147

    // test original file

   148

    if (stat(img_path, &st_img) < 0)

   149

        RETURN_ERROR(PT_ERR_IMG_STAT);

   150

   151

    // test cache file

   152

    if (stat(cache->path, &st_cache) < 0) {

   153

        // always stale if it doesn't exist yet

   154

        if (errno == ENOENT)

   155

            return PT_CACHE_NONE;

   156

        else

   157

            RETURN_ERROR(PT_ERR_CACHE_STAT);

   158

    }

   159

   160

    // compare mtime

   161

    if (st_img.st_mtime > st_cache.st_mtime)

   162

        return PT_CACHE_STALE;

   163

   164

    // read version

   165

    if ((ver = pt_cache_version(cache)) < 0)

   166

        // fail

   167

        return ver;

   168

   169

    // compare version

   170

    if (ver != PT_CACHE_VERSION)

   171

        return PT_CACHE_INCOMPAT;

   172

   173

    // ok, should be in order

   174

    return PT_CACHE_FRESH;

   175

}

   176

   177

void pt_cache_info (struct pt_cache *cache, struct pt_image_info *info)

   178

{

   179

    struct stat st;

   180

   181

    if (cache->file)

   182

        // img info

   183

        pt_png_info(&cache->file->header.png, info);

   184

   185

    // stat

   186

    if (stat(cache->path, &st) < 0) {

   187

        // unknown

   188

        info->cache_mtime = 0;

   189

        info->cache_bytes = 0;

   190

        info->cache_blocks = 0;

   191

   192

    } else {

   193

        // store

   194

        info->cache_version = pt_cache_version(cache);

   195

        info->cache_mtime = st.st_mtime;

   196

        info->cache_bytes = st.st_size;

   197

        info->cache_blocks = st.st_blocks;

   198

    }

   199

}

   200

   201

static int pt_cache_tmp_name (struct pt_cache *cache, char tmp_path[], size_t tmp_len)

   202

{

   203

    // get .tmp path

   204

    if (path_with_fext(cache->path, tmp_path, tmp_len, ".tmp"))

   205

        RETURN_ERROR(PT_ERR_PATH);

   206

   207

    return 0;

   208

}

   209

   210

/**

   211

 * Compute and return the full size of the .cache file

   212

 */

   213

static size_t pt_cache_size (size_t data_size)

   214

{

   215

    assert(sizeof(struct pt_cache_file) == PT_CACHE_HEADER_SIZE);

   216

   217

    return sizeof(struct pt_cache_file) + data_size;

   218

}

   219

   220

/**

   221

 * Open the .tmp cache file as an fd for writing

   222

 */

   223

static int pt_cache_open_tmp_fd (struct pt_cache *cache, int *fd_ptr)

   224

{

   225

    int fd;

   226

    char tmp_path[1024];

   227

    int err;

   228

   229

    // get .tmp path

   230

    if ((err = pt_cache_tmp_name(cache, tmp_path, sizeof(tmp_path))))

   231

        return err;

   232

   233

    // open for write, create, fail if someone else already opened it for update

   234

    if ((fd = open(tmp_path, O_RDWR | O_CREAT | O_EXCL, 0644)) < 0)

   235

        RETURN_ERROR(PT_ERR_CACHE_OPEN_TMP);

   236

   237

    // ok

   238

    *fd_ptr = fd;

   239

   240

    return 0;

   241

}

   242

   243

   244

/**

   245

 * Mmap the pt_cache_file using pt_cache_size(data_size)

   246

 */

   247

static int pt_cache_open_mmap (struct pt_cache *cache, struct pt_cache_file **file_ptr, size_t data_size, bool readonly)

   248

{

   249

    int prot = 0;

   250

    void *addr;

   251

   252

    // determine prot

   253

    prot |= PROT_READ;

   254

   255

    if (!readonly) {

   256

        assert(cache->mode & PT_OPEN_UPDATE);

   257

   258

        prot |= PROT_WRITE;

   259

    }

   260

   261

    // mmap() the full file including header

   262

    if ((addr = mmap(NULL, pt_cache_size(data_size), prot, MAP_SHARED, cache->fd, 0)) == MAP_FAILED)

   263

        RETURN_ERROR(PT_ERR_CACHE_MMAP);

   264

   265

    // ok

   266

    *file_ptr = addr;

   267

   268

    return 0;

   269

}

   270

   271

int pt_cache_open (struct pt_cache *cache)

   272

{

   273

    struct pt_cache_header header;

   274

    int err;

   275

   276

    // ignore if already open

   277

    if (cache->file)

   278

        return 0;

   279

   280

    // open the .cache in readonly mode

   281

    if ((err = pt_cache_open_read_fd(cache, &cache->fd)))

   282

        return err;

   283

   284

    // read in header

   285

    if ((err = pt_cache_read_header(cache->fd, &header)))

   286

        JUMP_ERROR(err);

   287

   288

    // check version

   289

    if (header.version != PT_CACHE_VERSION)

   290

        JUMP_SET_ERROR(err, PT_ERR_CACHE_VERSION);

   291

   292

    // mmap the header + data

   293

    if ((err = pt_cache_open_mmap(cache, &cache->file, header.data_size, true)))

   294

        JUMP_ERROR(err);

   295

   296

    // done

   297

    return 0;

   298

   299

error:

   300

    // cleanup

   301

    pt_cache_abort(cache);

   302

   303

    return err;

   304

}

   305

   306

/**

   307

 * Write out the cache header into the opened file

   308

 */

   309

static int pt_cache_write_header (struct pt_cache *cache, const struct pt_cache_header *header)

   310

{

   311

    size_t len = sizeof(*header);

   312

    const char *buf = (const char *) header;

   313

   314

    // seek to start

   315

    if (lseek(cache->fd, 0, SEEK_SET) != 0)

   316

        RETURN_ERROR(PT_ERR_CACHE_SEEK);

   317

   318

    // write out full header

   319

    while (len) {

   320

        ssize_t ret;

   321

   322

        // try and write out the header

   323

        if ((ret = write(cache->fd, buf, len)) <= 0)

   324

            RETURN_ERROR(PT_ERR_CACHE_WRITE);

   325

   326

        // update offset

   327

        buf += ret;

   328

        len -= ret;

   329

    }

   330

   331

    // done

   332

    return 0;

   333

}

   334

   335

/**

   336

 * Create a new .tmp cache file, open it, and write out the header.

   337

 */

   338

static int pt_cache_create (struct pt_cache *cache, struct pt_cache_header *header)

   339

{

   340

    int err;

   341

   342

    assert(cache->mode & PT_OPEN_UPDATE);

   343

   344

    // open as .tmp

   345

    if ((err = pt_cache_open_tmp_fd(cache, &cache->fd)))

   346

        return err;

   347

   348

    // write header

   349

    if ((err = pt_cache_write_header(cache, header)))

   350

        JUMP_ERROR(err);

   351

   352

    // grow file

   353

    if (ftruncate(cache->fd, pt_cache_size(header->data_size)) < 0)

   354

        JUMP_SET_ERROR(err, PT_ERR_CACHE_TRUNC);

   355

   356

    // mmap header and data

   357

    if ((err = pt_cache_open_mmap(cache, &cache->file, header->data_size, false)))

   358

        JUMP_ERROR(err);

   359

   360

    // done

   361

    return 0;

   362

   363

error:

   364

    // cleanup

   365

    pt_cache_abort(cache);

   366

   367

    return err;

   368

}

   369

   370

/**

   371

 * Rename the opened .tmp to .cache

   372

 */

   373

static int pt_cache_create_done (struct pt_cache *cache)

   374

{

   375

    char tmp_path[1024];

   376

    int err;

   377

   378

    // get .tmp path

   379

    if ((err = pt_cache_tmp_name(cache, tmp_path, sizeof(tmp_path))))

   380

        return err;

   381

   382

    // rename

   383

    if (rename(tmp_path, cache->path) < 0)

   384

        RETURN_ERROR(PT_ERR_CACHE_RENAME_TMP);

   385

   386

    // ok

   387

    return 0;

   388

}

   389

   390

/**

   391

 * Abort a failed cache update after cache_create

   392

 */

   393

static void pt_cache_create_abort (struct pt_cache *cache)

   394

{

   395

    char tmp_path[1024];

   396

    int err;

   397

   398

    // close open stuff

   399

    pt_cache_abort(cache);

   400

   401

    // get .tmp path

   402

    if ((err = pt_cache_tmp_name(cache, tmp_path, sizeof(tmp_path)))) {

   403

        log_warn_errno("pt_cache_tmp_name: %s: %s", cache->path, pt_strerror(err));

   404

   405

        return;

   406

    }

   407

   408

    // remove .tmp

   409

    if (unlink(tmp_path))

   410

        log_warn_errno("unlink: %s", tmp_path);

   411

}

   412

   413

int pt_cache_update (struct pt_cache *cache, struct pt_png_img *img, const struct pt_image_params *params)

   414

{

   415

    struct pt_cache_header header;

   416

    int err;

   417

   418

    // check mode

   419

    if (!(cache->mode & PT_OPEN_UPDATE))

   420

        RETURN_ERROR(PT_ERR_OPEN_MODE);

   421

   422

    // close if open

   423

    if ((err = pt_cache_close(cache)))

   424

        return err;

   425

   426

    // prep header

   427

    header.version = PT_CACHE_VERSION;

   428

    header.format = PT_IMG_PNG;

   429

   430

    // read img header

   431

    if ((err = pt_png_read_header(img, &header.png, &header.data_size)))

   432

        return err;

   433

   434

    // save any params

   435

    if (params)

   436

        header.params = *params;

   437

   438

    // create/open .tmp and write out header

   439

    if ((err = pt_cache_create(cache, &header)))

   440

        return err;

   441

   442

    // decode to disk

   443

    if ((err = pt_png_decode(img, &cache->file->header.png, &cache->file->header.params, cache->file->data)))

   444

        goto error;

   445

   446

    // done, commit .tmp

   447

    if ((err = pt_cache_create_done(cache)))

   448

        goto error;

   449

   450

    return 0;

   451

   452

error:

   453

    // cleanup .tmp

   454

    pt_cache_create_abort(cache);

   455

   456

    return err;

   457

}

   458

   459

int pt_cache_tile (struct pt_cache *cache, struct pt_tile *tile)

   460

{

   461

    int err;

   462

   463

    // ensure open

   464

    if ((err = pt_cache_open(cache)))

   465

        return err;

   466

   467

    // render

   468

    if ((err = pt_png_tile(&cache->file->header.png, cache->file->data, tile)))

   469

        return err;

   470

   471

    return 0;

   472

}

   473

   474

int pt_cache_close (struct pt_cache *cache)

   475

{

   476

    if (cache->file != NULL) {

   477

        if (munmap(cache->file, sizeof(struct pt_cache_file) + cache->file->header.data_size))

   478

            RETURN_ERROR(PT_ERR_CACHE_MUNMAP);

   479

   480

        cache->file = NULL;

   481

    }

   482

   483

    if (cache->fd >= 0) {

   484

        if (close(cache->fd))

   485

            RETURN_ERROR(PT_ERR_CACHE_CLOSE);

   486

   487

        cache->fd = -1;